Java 코테용 정리

자바는 원시 타입을 제외하면 모두 참조 타입이다.

 

[ 입출력 ]

• 테스트 케이스 이용
• System.setIn(new FileInputSteam("input.txt"))
• 테스트 케이스 하나하나 입력하지 않고, 파일로 실행하기

 

• 문자열 입력 받을 때 Scanner가 아니라 BufferedReader를 사용하자.
• import java.io.*;
• Scanner가 공백, 개행 시 나눠주는 것이 편하지만 느리다.
• BufferedReader는 하나 하나 사용자가 나누어주어야 한다.  // split 보다 BufferedReader가 더 빠르다.
• StringTokenizer를 이용한다.
• 예시

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

String line = bf.readLine(); // 한 줄 받아오기

StringTokenizer st = new StringTokenizer(line, " ");

int sum = 0;

while(st.hasMoreTokens())

sum += Integer.parseInt(st.nextToken());

System.out.println(sum);

 

 

 

 

[ 문자열 ]

• String대신 StringBuilder를 이용하여 문자열을 처리한다.
• 해당 기능을 이용하면, 문자열 변경 시 새로 생성하지 않는다.
• StringBuilder에서 문자열 출력시 toString() 메소드 이용
• sb.toString();
• String to Int
• Integer.parseInt(sb.toString());
•  

StringBuffer sb = new StringBuffer(["초기 문자열"]);

sb.append("String str");

sb.insert(int offset, String str); // 해당 인덱스에 값을 삽입

sb.charAt(int index); // 해당 인덱스 위치의 문자 출력

sb.delete(int start, int end); // start ~ end-1 까지의 문자 제거

sb.replace(int start, int end, String str); // start ~ end-1 까지 위치를 str로 대체

sb.substring(int start, int end); // start ~ end-1 위치 까지 출력

sb.toString(); // 현재 문자열을 String 형으로 변환

sb.reverse(); // 문자열 뒤집기

 

• String to char to int
• String test = "A";
• int it = test.charAt(0);
• // 문자로 배열 접근
• arr[test.charAt(0)-'A'];

 

[ 배열 ]

• int[]  arr = new arr[10];
• int[]  arr = {1, 2, 3};
• int[]  arr = new arr[]{1,1,1}
• 배열 선언 시 new 로 생성한 경우 기본 값 자동으로 출력.
• Arrays.fill(배열 이름, 값);
• 배열 특정 값으로 채우기

 

[ ArrayList ]

• import java.util.ArrayList
• C++의 Vector에 해당하는 역할 => 동적 배열

import java.util.ArrayList;



ArrayList<Integer> arrlist = new ArrayList<Integer>(); // 초기화 방법 모름. 그냥 넣기



arrList.add(E e); // 원소 e를 맨 뒤에 추가



arrList.add(int index, E e) // index 위치에 원소 e를 추가



arrList.clear(); // 원소 전부 삭제



arrList.contains(object o); // 해당 원소가 있는지 확인 return boolean



arrList.get(int index); // 해당 인덱스 원소 리턴 return E



arrList.isEmpty();



arrList.remove(int index); // 해당 인덱스 제거

arrList.remove(Object o); // 해당 원소 제거 -> 정수의 경우 Interger 값 이용 필요



arrList.size();

 

 

[ Stack ]

• import java.util.Stack;

import java.util.Stack;



Stack<Integer> st= new Stack<Integer>(); // 초기화 방법 모름. 그냥 넣기



st.empty();



st.peek(); // 가장 맨 위에 위치한 값 반환



st.pop(); // 가장 맨 위에 위치한 값 제거 후 반환



st.push(E item); // 가장 맨 위 item 추가



st.search(Object O); // O의 위치 반환, 없으면 -1 return

 

 

[ Queue, Deque ]

• import java.util.LinkedList; //import
• import java.util.Queue; //import
•  

import java.util.LinkedList; //import

import java.util.Queue; //import



Queue<Integer> queue = new LinkedList<>();

Queue<String> queue = new LinkedList<>();



queue.add(1);

queue.offer(3);



queue.poll(); // queue에 첫번째 값을 반환하고 제거 비어있다면 null



queue.peek(); // queue의 첫번째 값 반환



queue.remove(); // queue에 첫번째 값 제거



queue.clear(); // queue 초기화

 

[ Hashset ]

• import java.util.HashSet;
• c++의 unordered_set

import java.util.HashSet;



HashSet<Integer> hashSet = new HashSet<>();

HashSet<Point> hashSetPoint = new HashSet<>();

hashSet.add(E e) // e를 셋에 추가

hashSet.clear() // 셋의 데이터를 전부 삭제

hashSet.contains(Object o) // 셋에 o가 있다면 true, 없으면 false

hashSet.isEmpty() // 셋이 비었으면 true, 아니면 false

hashSet.remove(Object o) // 셋에서 o를 제거

hashSet.size()

 

 

[ Treeset ]

• import java.util.TreeSet;
• c++의 set

import java.util.TreeSet;

TreeSet<Integer> treeSet = new TreeSet<>();
TreeSet<Point> treeSetPoint = new TreeSet<>(); 

treeSet.add(E e) // e를 셋에 추가 

treeSet.clear() // 셋의 데이터를 전부 삭제 

treeSet.contains(Object o) // 셋에 o가 있다면 true, 없으면 false 

treeSet.first()     // 셋에서 가장 값이 낮은 원소 반환

treeSet.last()       // 셋에서 가장 값이 높은 원소 반환

treeSet.isEmpty()   // 셋이 비었으면 true, 아니면 false


treeSet.remove(Object o)   // 셋에서 o를 제거

treeSet.size() 

 

 

 

[ Priority Queue ]

• import java.util.PriorityQueue;
•  

import java.util.PriorityQueue;

//int형 priorityQueue 선언 (우선순위가 낮은 숫자 순)

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

//int형 priorityQueue 선언 (우선순위가 높은 숫자 순)

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());


priorityQueue.add(2); // priorityQueue 값 2 추가

priorityQueue.offer(3); // priorityQueue 값 3 추가


priorityQueue.poll(); // priorityQueue에 첫번째 값을 반환하고 제거 비어있다면 null

priorityQueue.remove(); // priorityQueue에 첫번째 값 제거

priorityQueue.clear(); // priorityQueue에 초기화

priorityQueue.peek(); // priorityQueue에 첫번째 값 참조 = 1

 

[ Hash Map ]

• c++의 unordered_map
•  

HashMap<String,String> map2 = new HashMap<>();//new에서 타입 파라미터 생략가능

HashMap<String,String> map3 = new HashMap<>(map1);//map1의 모든 값을 가진 HashMap생성


map.put(1,"사과"); //값 추가

map.remove(1); //key값 1 제거

map.clear(); //모든 값 제거


System.out.println(map); //전체 출력 : {1=사과, 2=바나나, 3=포도}


System.out.println(map.get(1));//key값 1의 value얻기 : 사과

//entrySet() 활용

for (Entry<Integer, String> entry : map.entrySet()) {

System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());

}


//KeySet() 활용

for(Integer i : map.keySet()){ //저장된 key값 확인

System.out.println("[Key]:" + i + " [Value]:" + map.get(i));

}

 

[ Tree Map ]

• c++의 map
•  

TreeMap<Integer,String> map2 = new TreeMap<>();//new에서 타입 파라미터 생략가능 
TreeMap<Integer,String> map3 = new TreeMap<>(map1);//map1의 모든 값을 가진 TreeMap생성 

map.put(1,"사과"); //값 추가

map.remove(1); //key값 1 제거

map.clear(); //모든 값 제거


System.out.println(map); //전체 출력 : {1=사과, 2=복숭아, 3=수박} 

System.out.println(map.get(1));//key값 1의 value얻기 : 사과 

System.out.println(map.firstEntry());//최소 Entry 출력 : 1=사과 

System.out.println(map.firstKey());//최소 Key 출력 : 1 

System.out.println(map.lastEntry());//최대 Entry 출력: 3=수박 

System.out.println(map.lastKey());//최대 Key 출력 : 3

System.out.println(map.get(1));//key값 1의 value얻기 : 사과


//entrySet() 활용 
for (Entry<Integer, String> entry : map.entrySet()) { 
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue()); 
}


//KeySet() 활용 
for(Integer i : map.keySet()){ //저장된 key값 확인 
    System.out.println("[Key]:" + i + " [Value]:" + map.get(i)); 
}

 

 

[ 정렬 ]

• 배열 정렬  // 원시 타입 및 string도 가능하다.
• Arrays.sort(배열);
• Arrays.sort(arr);
• Arrays.sort(arr); // 오름차순
• Arrays.sort(arr, Collections.reverseOrder()); // 내림차순

 

• ArrayList정렬
• Collections.sort(myArr); // 오름차순
• Collections.sort(myArr, Collections.reverseOrder()); // 오름차순

 

 

• 사용자 정의 정렬
• 1. Comparable
• 사용자 정의 클래스에 Comparable 인터페이스를 Implements하여 정렬
• 2. Comparator
• Arrays.sort, Collections.sort에 Comparator 인터페이스를 재정의한 클래스, 익명 클래스 전달하여 정렬
• return -1 이면 순서 변경 x / return 1이면 순서 변경 o

 

 

순열 조합

 

 

 

public static boolean np(){
    int i = N-1;
        
    // input의 뒤에서부터 탐색하여 i보다 작은 i-1인덱스 찾기
    // 교환할 인덱스는 i-1이다.
    // input은 오름차순 정렬되어 있다.
    while(i>0 && input[i-1] >= input[i])
        --i;

    // 더 이상 앞자리가 없는 상황 : 현 순열의 상태가 가장 큰 순열(마지막 순열)
    if(i==0)
        return false;

    // i-1과 교환할 j인덱스 찾기
    // j인덱스는 i-1보다 커야 한다.
    int j = N-1;
    while(input[i-1] >= input[j])
        --j;

    swap(i-1,j);

    // 순열을 다시 오름차순으로 정렬.
    int k = N-1;
    while(i<k){
        swap(i,k);
        i++;
        k--;
    }
    return true;
}