[Java] Java로 코딩테스트 대비 알아두면 좋은 점

1. Integer 클래스

Integer는 기본 자료형인 int를 객체로 다룰 수 있도록 제공되는 래퍼 클래스입니다. 숫자를 다룰 때, 다양한 유틸리티 메서드와 상수를 제공합니다.

주요 특징

• 기본 자료형 int의 객체 버전.
• null 값을 허용할 수 있음 (기본 자료형은 허용 불가).
• 정수 값의 변환, 비교, 상수 제공 등의 유틸리티 메서드 포함.

주요 메서드

valueOf()

• 문자열 또는 숫자를 Integer 객체로 변환.

Integer num = Integer.valueOf("123"); // 문자열 -> Integer
Integer num2 = Integer.valueOf(456); // 숫자 -> Integer

* ValueOf()는 String 클래스에서도 자주 사용한다.  Integer 때와 반대로 숫자를 문자열로 바꿔줄 수 있는 기능을 해준다.

// BufferWriter를 사용해서 출력해야 될 때 사용하게 된다
Spring output = String.valueOf(123);		// 숫자 -> 문자열

 

parseInt()

• 문자열을 기본 자료형 int로 변환.

int num = Integer.parseInt("789");

toString()

• 정수를 문자열로 변환.

String str = Integer.toString(100); // "100"

compare()

• 두 정수를 비교 (결과: -1, 0, 1).

int result = Integer.compare(5, 10); // -1 (5 < 10)

MAX_VALUE / MIN_VALUE

• 정수형의 최대값, 최소값.

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648

bitCount()

• 숫자를 2진수로 변환했을 때 1의 개수를 반환.

int count = Integer.bitCount(7); // 7(111) -> 3

코딩 테스트 활용 예

• 문자열을 숫자로 변환할 때:

String input = "42";
int num = Integer.parseInt(input);

• 두 숫자의 크기를 비교할 때:

int a = 5, b = 10;
System.out.println(Integer.compare(a, b)); // -1

2. Character 클래스

Character는 기본 자료형 char을 객체로 다룰 수 있도록 제공되는 래퍼 클래스입니다. 문자 데이터의 특성을 검사하거나 변환하는 메서드를 제공합니다.

주요 특징

• 기본 자료형 char의 객체 버전.
• 문자의 유효성 검사, 변환 등의 유틸리티 메서드 포함.

주요 메서드

isDigit()

• 문자가 숫자인지 확인.

boolean result = Character.isDigit('5'); // true

isLetter()

• 문자가 알파벳인지 확인.

boolean result = Character.isLetter('a'); // true

isLetterOrDigit()

• 문자가 알파벳 또는 숫자인지 확인.

boolean result = Character.isLetterOrDigit('1'); // true

isUpperCase() / isLowerCase()

• 문자가 대문자인지 또는 소문자인지 확인. (true/false 반환)

boolean upper = Character.isUpperCase('A'); // true
boolean lower = Character.isLowerCase('a'); // true

toUpperCase() / toLowerCase()

• 문자를 대문자 또는 소문자로 변환.
• String 자료형일때도 사용 가능

char upper = Character.toUpperCase('b'); // 'B'
char lower = Character.toLowerCase('D'); // 'd'

isWhitespace()

• 문자가 공백(스페이스, 탭 등)인지 확인.

boolean result = Character.isWhitespace(' '); // true

코딩 테스트 활용 예

• 문자 검사 및 변환

char ch = '9';
if (Character.isDigit(ch)) {
    System.out.println(ch + " is a digit."); // 9 is a digit.
}

• 문자열을 변환할 때

String input = "Hello";
for (char c : input.toCharArray()) {
    System.out.print(Character.toLowerCase(c)); // hello
}

• 문자열에서 대문자 개수 

     Scanner scn = new Scanner(System.in);

     String a = scn.nextLine();

     char b = scn.next().charAt(0);

     int cnt = 0;
     for(char c : a.toCharArray()) {
         if(Character.isUpperCase(c)) {
             cnt++;
         }
     }
    System.out.println(cnt);

3. java.util.* 패키지

이 패키지는 컬렉션 프레임워크와 유틸리티 기능을 제공하며, 데이터 구조와 알고리즘 구현에 유용한 도구를 포함합니다.

주요 클래스

Collections

• 배열과 다르게 동적으로 크기 전환이 가능하다.
• Collections.sort(List): 리스트 정렬.
  • 역순 정렬 : Collctions.sort(List, Collections.reverseOrder()))
  • Tim sort 기반(Insertion Sort + Merge Sort) 정렬 방식
• Collections.max(Collection), Collections.min(Collection): 최대값, 최소값 찾기.
• Collections.binarySearch(list,target) 
  • 이진탐색을 통한 값의 인덱스 찾기(없으면 -1)
  • 시간복잡도 O(log n) 

Arrays

• 배열을 효과적으로 다루기 위한 유틸리티 클래스
• Arrays.parallelSort(array)
• Arrays.sort(array) : 배열 정렬
  • Dual - Pivot Quick Sort 기반 (기존의 Quick Sort 보다 Pivot을 2개 사용함으로 더 빠르다)
  • 참조지역성 원리로 인해 두 정렬 방식이 다르다.
• Arrays.BinarySearch(array,key) : 이진 탐색을 통해 원하는 값을 찾는다
• Arrays.equal(array1,array2) : 두 배열이 같은 지 비교
• Arrays.asList(array) :  배열을 List로 변환할 때 사용
• Arrays를 사용해서 배열의 최댓값, 최솟값, 합 구하기
  • int minValue = Arrays.stream(arr).min().getAsInt();
  • int maxValue = Arrays.stream(arr).max().getAsInt();
  • int sumValue = Arrays.stream(arr).sum();

ArrayList

• 가변 크기의 배열로 동적으로 데이터를 저장.
• 활용: 동적 데이터 저장 및 빠른 탐색.
• 정렬 하고 싶으면 (ArrayList).sort(null or Collections.reverseOrder())로 바로 정렬 할 수 있다. 
• arraylist.get(index) : 인덱스에 따른 값 추출
• arraylist.add(value) : 자료형에 따른 값 삽입
• ArrayList는 List 인터페이스를 구현한 클래스이므로, Collections 클래스의 메서드를 사용할 수 있다.

        // 1. Collections 클래스 사용 예시
        List<Integer> arr = new ArrayList<>();
        arr.add(5);
        arr.add(3);
        arr.add(8);
        arr.add(1);

        // 리스트 정렬 (오름차순) 
        Collections.sort(arr);												// = arr.sort(null);
        System.out.println("오름차순 정렬: " + arr); // 출력: [1, 3, 5, 8]

        // 리스트 정렬 (내림차순)  
        Collections.sort(arr, Collections.reverseOrder());					// = arr.sort(Collections.reverseOrder());
        System.out.println("내림차순 정렬: " + arr); // 출력: [8, 5, 3, 1]

        // 이진 탐색 (리스트가 정렬되어 있어야 함)
        int index = Collections.binarySearch(arr, 5);
        System.out.println("이진 탐색 결과 (5의 인덱스): " + index); // 출력: 1

        // 2. Arrays 클래스 사용 예시
        Integer[] a = {5, 3, 8, 1, 2};

        // 배열 정렬 (오름차순)
        Arrays.sort(a);
        System.out.println("배열 오름차순 정렬: " + Arrays.toString(a)); // 출력: [1, 2, 3, 5, 8]
        // 배열 정렬 (내림차순 ,Primitive 타입일 떄는 안됨(int → Integer)
        Arrays.sort(a,Collections.reverseOrder());
         System.out.println("배열 내림차순 정렬: " + Arrays.toString(a)); // 출력: [8 ,5 ,3 ,2 ,1]

        // 배열 이진 탐색 (배열이 정렬되어 있어야 함)
        int arrayIndex = Arrays.binarySearch(a, 3);
        System.out.println("배열 이진 탐색 결과 (3의 인덱스): " + arrayIndex); // 출력: 2

        // 추가: 배열을 리스트로 변환
        List<Integer> listFromArray = Arrays.asList(5, 3, 8, 1, 2);
        System.out.println("배열을 리스트로 변환: " + listFromArray); // 출력: [5, 3, 8, 1, 2]

Stack

• Stack 선언 ex) Stack<Integer> stack = new Stack<>();
• stack,isEmpty() : 스택이 비었는지 알려줌 : true/false
• stack.peek() : 스택의 맨 위의 원소를 반환
• stack은 후위선출(LIFO) 구조를 따른다
  • stack.push(value) : 스택에 item 삽입
  • stack.pop() : 스택의 맨 위의 원소 제거
• stack.search : 스택에 주어진 객체를 찾아서 인덱스 반환(없으면 -1 반환)

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // Stack 선언
        Stack<Integer> stack = new Stack<>();

        // 스택이 비어있는지 확인
        System.out.println("스택이 비어있나요? " + stack.isEmpty()); // true

        // 스택에 값 추가 (push)
        stack.push(10);
        stack.push(20);
        stack.push(30);

        // 스택의 맨 위 값 확인 (peek)
        System.out.println("스택의 맨 위 값: " + stack.peek()); // 30

        // 스택의 값 제거 (pop)
        System.out.println("스택에서 제거된 값: " + stack.pop()); // 30
        System.out.println("스택의 맨 위 값: " + stack.peek()); // 20

        // 스택에 특정 값이 있는지 검색 (search)
        int valueToFind = 10;
        int index = stack.search(valueToFind);
        if (index != -1) {
            System.out.println(valueToFind + "는 스택의 " + index + "번째 위치에 있습니다."); // 10는 스택의 2번째 위치에 있습니다.
        } else {
            System.out.println(valueToFind + "는 스택에 없습니다.");
        }

        // 스택이 비어있는지 다시 확인
        System.out.println("스택이 비어있나요? " + stack.isEmpty()); // false

        // 스택의 모든 값 제거
        while (!stack.isEmpty()) {
            System.out.println("스택에서 제거된 값: " + stack.pop());
        }

        // 스택이 비어있는지 최종 확인
        System.out.println("스택이 비어있나요? " + stack.isEmpty()); // true
    }
}

LinkedList

• 양방향 연결 리스트 구현.
• 활용: 큐(Queue), 덱(Deque) 등으로 사용.
  • Queue
    
    • 선입선출(FIFO) 구조 
    • add(e) / offer(e): 요소를 추가합니다.
    • remove() / poll(): 요소를 제거하고 반환합니다.
    • element() / peek(): 요소를 제거하지 않고 반환합니다.
  • Deque
    • 양쪽 끝에서 요소를 추가하거나 제거할 수 있는 자료구조
    • FIFO와 LIFO (Last-In-First-Out, 후입선출) 모두 지원
    • Stack과 Queue의 기능을 모두 제공
    • addFirst(e) / offerFirst(e): 앞쪽에 요소를 추가
    • addLast(e) / offerLast(e): 뒤쪽에 요소를 추가
    • removeFirst() / pollFirst(): 앞쪽에서 요소를 제거하고 반환
    • removeLast() / pollLast(): 뒤쪽에서 요소를 제거하고 반환
    • getFirst() / peekFirst(): 앞쪽의 요소를 제거하지 않고 반환
    • getLast() / peekLast(): 뒤쪽의 요소를 제거하지 않고 반환

Deque<Integer> deque = new LinkedList<>();
deque.add(1); // 큐로 사용
deque.addFirst(0); // 덱 기능

 

 

HashMap / TreeMap

• HashMap: 키-값 쌍 저장, 빠른 조회(O(1)).
• TreeMap: 키를 자동 정렬하며 저장(레드-블랙 트리 기반 - O(logn)).
• 활용: 키-값 기반 데이터 저장 및 조회.
• Map은 Python에서 딕셔너리(dict)와 같음

1. HashMap 예시

	   public static void main(String[] args) {
	        // HashMap 생성
	        Map<String, Integer> hashMap = new HashMap<>();

	        // put: 키-값 쌍 추가
	        hashMap.put("Apple", 10);
	        hashMap.put("Banana", 5);
	        hashMap.put("Cherry", 20);

	        // get: 키로 값 조회
	        System.out.println("Apple의 값: " + hashMap.get("Apple")); // 10

	        // getOrDefault: 키가 없을 경우 기본값 반환
	        System.out.println("Mango의 값 (기본값 0): " + hashMap.getOrDefault("Mango", 0)); // 0

	        // keySet: 모든 키 조회
	        System.out.println("모든 키: " + hashMap.keySet()); // [Apple, Banana, Cherry]

	        // containsKey: 키 존재 여부 확인
	        System.out.println("Banana가 존재하는가? " + hashMap.containsKey("Banana")); // true

	        // equals: 두 HashMap 비교
	        Map<String, Integer> anotherMap = new HashMap<>();
	        anotherMap.put("Apple", 10);
	        anotherMap.put("Banana", 5);
	        anotherMap.put("Cherry", 20);

	        System.out.println("두 HashMap이 같은가? " + hashMap.equals(anotherMap)); // true
	        
	        hashMap.remove("Apple");					// 값 제거
	        anotherMap.put("Apple", anotherMap.getOrDefault("Apple", 0)+1);		//값 변경
	    }

2. TreeMap 예시

import java.util.Map;
import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        // TreeMap 생성 (키를 기준으로 정렬됨)
        Map<String, Integer> treeMap = new TreeMap<>();

        // put: 키-값 쌍 추가
        treeMap.put("Apple", 10);
        treeMap.put("Banana", 5);
        treeMap.put("Cherry", 20);

        // get: 키로 값 조회
        System.out.println("Apple의 값: " + treeMap.get("Apple")); // 10

        // getOrDefault: 키가 없을 경우 기본값 반환
        System.out.println("Mango의 값 (기본값 0): " + treeMap.getOrDefault("Mango", 0)); // 0

        // keySet: 모든 키 조회 (정렬된 순서로 반환)
        System.out.println("모든 키: " + treeMap.keySet()); // [Apple, Banana, Cherry]

        // containsKey: 키 존재 여부 확인
        System.out.println("Banana가 존재하는가? " + treeMap.containsKey("Banana")); // true

        // equals: 두 TreeMap 비교
        Map<String, Integer> anotherMap = new TreeMap<>();
        anotherMap.put("Apple", 10);
        anotherMap.put("Banana", 5);
        anotherMap.put("Cherry", 20);

        System.out.println("두 TreeMap이 같은가? " + treeMap.equals(anotherMap)); // true
        
        // firstKey: 가장 작은 키 반환
        String firstKey = treeMap.firstKey();
        System.out.println("가장 작은 키: " + firstKey); // Apple

        // lastKey: 가장 큰 키 반환
        String lastKey = treeMap.lastKey();
        System.out.println("가장 큰 키: " + lastKey); // Mango

        // firstEntry: 가장 작은 키와 값 반환
        Map.Entry<String, Integer> firstEntry = treeMap.firstEntry();
        System.out.println("가장 작은 키와 값: " + firstEntry.getKey() + " = " + firstEntry.getValue()); // Apple = 10

        // lastEntry: 가장 큰 키와 값 반환
        Map.Entry<String, Integer> lastEntry = treeMap.lastEntry();
        System.out.println("가장 큰 키와 값: " + lastEntry.getKey() + " = " + lastEntry.getValue()); // Mango = 15
    }
}

ex) https://cote.inflearn.com/contest/10/problem/04-01

public static void main(String[] args) throws Exception {
		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		String s = scn.nextLine();
		char answer = ' ';
		
		HashMap<Character,Integer> map = new HashMap<>();
		for(char x : s.toCharArray()) {
			map.put(x, map.getOrDefault(x, 0)+1);
		}
		
		int value = Integer.MIN_VALUE;
		for(char x : map.keySet()) {
			if(value < map.get(x)) {
				answer = x;
				value = map.get(x);
			}
		}
		System.out.println(answer);
		
	}

HashSet / TreeSet

• HashSet: 중복 없는 데이터 저장.
• TreeSet: 중복 없는 데이터 + 자동 정렬.(이진탐색트리기반 - O(logn))
• 활용: 중복 제거, 고유값 처리.
• Python에서도 set()으로 같음

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
System.out.println(set.contains(1)); // true

PriorityQueue

• 힙(Heap) 기반 우선순위 큐 구현.
• 활용: 최소값, 최대값 기반 정렬 작업.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(3);
pq.add(1);
pq.add(2);
System.out.println(pq.poll()); // 1 (최소값)

Scanner

• 표준 입력(System.in)으로 데이터 읽기.
• 활용: 입력받은 데이터를 파싱 및 처리.

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String str = sc.next();

4. java.io.* 패키지

이 패키지는 입출력 작업(IO)을 위한 클래스를 제공합니다. 코딩 테스트에서는 대규모 데이터 입출력 처리에 주로 사용됩니다.

주요 클래스

BufferedReader

• 빠른 입력 처리를 위해 버퍼를 사용하는 입력 클래스.
• 활용: 대량 데이터 입력 처리.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String input = br.readLine();
int num = Integer.parseInt(input);

BufferedWriter

• 빠른 출력 처리를 위해 버퍼를 사용하는 출력 클래스.
• 활용: 대량 데이터 출력 처리.

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
bw.write("Hello, World!");
bw.newLine();
bw.flush();

InputStreamReader / OutputStreamWriter

• 바이트 스트림을 문자 스트림으로 변환.
• 활용: 다양한 인코딩 지원.

InputStreamReader isr = new InputStreamReader(System.in);
OutputStreamWriter osw = new OutputStreamWriter(System.out);

PrintWriter

• 다양한 출력 형식을 지원하는 클래스.
• 활용: 빠르고 포맷된 출력.

PrintWriter pw = new PrintWriter(System.out);
pw.println("Formatted output");
pw.flush();

코딩 테스트에서의 활용 예시

빠른 입력/출력 처리

• 많은 데이터 입력/출력 시, BufferedReader와 BufferedWriter 사용
• BufferedReader: readLine()을 사용하여 한 줄 입력을 받음.
  • Scanner보다 속도가 빠름.
• StringTokenizer: nextToken()을 사용해 공백을 기준으로 문자열을 분리.
• BufferedWriter: write()를 사용해 출력.
  • flush()로 즉시 출력해야 결과가 보임.
• 예시) 두 개의 배열을 입력받아 합친 후 정렬하고, 최댓값과 최솟값을 출력하세요

import java.io.*;
import java.util.*;

public class Main {
	 public static void main(String[] args) throws IOException {
	        // 입력을 위한 BufferedReader
	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

	        // 첫 번째 배열 입력
	        StringTokenizer st = new StringTokenizer(br.readLine());
	        int N = Integer.parseInt(st.nextToken()); // 첫 번째 배열의 크기
	        st = new StringTokenizer(br.readLine());
	        List<Integer> list = new ArrayList<>();
	        for (int i = 0; i < N; i++) {
	            list.add(Integer.parseInt(st.nextToken()));
	        }

	        // 두 번째 배열 입력
	        st = new StringTokenizer(br.readLine());
	        int M = Integer.parseInt(st.nextToken()); // 두 번째 배열의 크기
	        st = new StringTokenizer(br.readLine());
	        for (int i = 0; i < M; i++) {
	            list.add(Integer.parseInt(st.nextToken()));
	        }

	        // 리스트 정렬
	        Collections.sort(list);

	        // 최댓값, 최솟값 찾기
	        int minValue = list.get(0);
	        int maxValue = list.get(list.size() - 1);

	        // 결과 출력
	        bw.write("정렬된 리스트: " + list + "\n");
	        bw.write("최솟값: " + minValue + "\n");
	        bw.write("최댓값: " + maxValue + "\n");

	        // 리소스 정리
	        br.close();
	        bw.flush();
	        bw.close();
	    }
}

 

코딩테스트에서 버퍼 입출력 방식을 사용할 때는 처음에 처리해야 될 부분이 다음과 같다

1.  Java.util 임포트(+ Java.io.* 랑 같이 많이 쓰니까 같이 임포트 해주자)
2. 메서드에 throws Exception 추가(버퍼메모리 오류 예외 처리(IOException))
3. 버퍼 입출력은 문자열 기반 → 정수자료형일때는 변환 필요
4. BufferedWriter는 출력(write) 후, flush()
5. 코드 작성 후에 반드시 BufferedReader, BufferedWriter close()

데이터 구조 활용

최단 경로 문제에서 PriorityQueue 사용

import java.util.*;

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.add(5);
        pq.add(1);
        pq.add(3);
        
        while (!pq.isEmpty()) {
            System.out.println(pq.poll()); // 1, 3, 5 순 출력
        }
    }
}

HashMap으로 빈도 계산

문자열에서 각 문자의 빈도수 계산

import java.util.*;

public class Main {
    public static void main(String[] args) {
        String str = "hello";
        Map<Character, Integer> freq = new HashMap<>();
        
        for (char c : str.toCharArray()) {
            freq.put(c, freq.getOrDefault(c, 0) + 1);
        }
        
        System.out.println(freq); // {h=1, e=1, l=2, o=1}
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

참고) 

[JAVA] 코딩테스트용 주요 함수 모음

https://eckrin.tistory.com/136

코테용 Java 라이브러리(자료구조) 정리

https://h-kyung.tistory.com/27

JAVA 코딩테스트 IDE사용 못할 경우, 자주 사용하는 함수 정리

https://st-lab.tistory.com/category/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0/Java

'자료구조/Java' 카테고리의 글 목록

https://velog.io/@kimmjieun/Java-%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8%EB%A5%BC-%EC%9C%84%ED%95%9C-%EC%9E%85%EC%B6%9C%EB%A0%A5-%ED%8C%81

[Java] 코딩테스트를 위한 입출력 팁