주제별 정리


Java Coding Test Cheatsheet

0. Frequently Used Libraries

import java.util.*;      // Data structures
import java.io.*;        // Fast I/O
import java.math.*;      // BigInteger, BigDecimal

1. Variable & Array Declaration

String[] arr1 = new String[5];
int[] arr2 = {1, 2, 3};
int N = 3;
int[] arr3 = new int[N];

2. Arrays Utility

Arrays.sort(arr);                                 // Ascending
Arrays.sort(arr, Collections.reverseOrder());     // Descending
Arrays.sort(arr, 0, 4);                           // Partial sort
Arrays.binarySearch(arr, 2);                      // Binary search
List<String> list = Arrays.asList(arr1);          // Convert to List
int[] tmp = Arrays.copyOfRange(arr, 0, 3);        // Slice

3. length / length() / size()

arr.length        // Arrays
str.length()      // String
list.size()       // Collections

4. String Handling

str.split(" ");
str.substring(0, 5);
str.charAt(i);
str.toUpperCase();
str.toLowerCase();
String[] letters = str.split("");
String newStr = str.substring(0,4) + "X" + str.substring(5);

5. HashMap

Map<String, Integer> map = new HashMap<>();
map.put("key", 1);
map.get("key");
map.containsKey("key");
map.getOrDefault("key", 0);
for (String k : map.keySet()) map.get(k);

6. ArrayList

List<String> list = new ArrayList<>();
list.add("a");
list.set(0, "b");
list.remove("b");
list.contains("a");
list.indexOf("a");

7. Queue (LinkedList)

Queue<Integer> q = new LinkedList<>();
q.offer(1);
q.poll();
q.peek();
q.clear();
q.isEmpty();

8. PriorityQueue

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

9. Math

Math.max(a, b);
Math.min(a, b);
Math.abs(x);
Math.ceil(x);
Math.floor(x);
Math.round(x);
String.format("%.2f", d);  // Round to 2 decimal
Math.pow(a, b);
Math.sqrt(x);

10. HashSet

Set<String> set = new HashSet<>();
set.add("a");
set.remove("a");
set.contains("a");

11. Stack

Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.pop();
stack.peek();

12. Deque (ArrayDeque)

Deque<Integer> dq = new ArrayDeque<>();
dq.addFirst(1);
dq.addLast(2);
dq.pollFirst();
dq.pollLast();

13. TreeSet

TreeSet<Integer> ts = new TreeSet<>();
ts.add(5);
ts.first();
ts.last();
ts.lower(5);
ts.higher(5);

14. TreeMap

TreeMap<String, Integer> tm = new TreeMap<>();
tm.put("apple", 3);
tm.firstKey();
tm.lastKey();

15. Fast I/O

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
String[] parts = br.readLine().split(" ");

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
bw.write("Hello\n");
bw.flush();
bw.close();

16. DFS

void dfs(int node) {
    visited[node] = true;
    for (int next : graph.get(node)) {
        if (!visited[next]) dfs(next);
    }
}

17. BFS

Queue<Integer> q = new LinkedList<>();
q.offer(start);
visited[start] = true;
while (!q.isEmpty()) {
    int cur = q.poll();
    for (int next : graph.get(cur)) {
        if (!visited[next]) {
            q.offer(next);
            visited[next] = true;
        }
    }
}

18. Sorting

list.sort(Comparator.naturalOrder());
list.sort(Comparator.reverseOrder());
people.sort(Comparator.comparingInt(p -> p.age));

19. DP (Fibonacci)

int[] dp = new int[N+1];
dp[0] = 0; dp[1] = 1;
for (int i = 2; i <= N; i++) dp[i] = dp[i-1] + dp[i-2];

20. Union-Find

int find(int x) {
    if (x != parent[x]) parent[x] = find(parent[x]);
    return parent[x];
}
void union(int a, int b) {
    a = find(a); b = find(b);
    if (a != b) parent[b] = a;
}

21. Bitmask

int bit = 0;
bit |= (1 << 3);
bit &= ~(1 << 3);
boolean on = (bit & (1 << 3)) != 0;
Integer.bitCount(bit);

22. Greedy

int[] coins = {500, 100, 50, 10};
int count = 0;
for (int coin : coins) {
    count += target / coin;
    target %= coin;
}

23. Prefix Sum

int[] prefix = new int[N+1];
for (int i = 0; i < N; i++) prefix[i+1] = prefix[i] + arr[i];

24. Sliding Window

int sum = 0;
for (int i = 0; i < k; i++) sum += arr[i];
int max = sum;
for (int i = k; i < N; i++) {
    sum += arr[i] - arr[i-k];
    max = Math.max(max, sum);
}

25. Sieve of Eratosthenes

boolean[] isPrime = new boolean[N+1];
Arrays.fill(isPrime, true);
for (int i = 2; i*i <= N; i++) {
    if (isPrime[i]) {
        for (int j = i*i; j <= N; j += i) isPrime[j] = false;
    }
}

26. Dijkstra

PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
int[] dist = new int[N+1];
Arrays.fill(dist, INF);
dist[start] = 0;
pq.offer(new int[]{start, 0});

27. Tree / LCA

void dfs(int node, int par, int d) {
    parent[node] = par;
    depth[node] = d;
    for (int next : tree.get(node)) {
        if (next != par) dfs(next, node, d+1);
    }
}

28. Coding Test Patterns

29. Backtracking (Permutation, Combination)

void permute(List<Integer> list, boolean[] used) {
    if (list.size() == N) {
        System.out.println(list);
        return;
    }
    for (int i = 0; i < N; i++) {
        if (!used[i]) {
            used[i] = true;
            list.add(arr[i]);
            permute(list, used);
            list.remove(list.size() - 1);
            used[i] = false;
        }
    }
}

30. Binary Search / Parametric Search

int left = 1, right = maxVal;
while (left <= right) {
    int mid = (left + right) / 2;
    if (condition(mid)) {
        answer = mid;
        right = mid - 1;
    } else {
        left = mid + 1;
    }
}

31. Recursion Optimization

32. String Algorithms (KMP)

int[] makeTable(String pattern) {
    int[] table = new int[pattern.length()];
    int j = 0;
    for (int i = 1; i < pattern.length(); i++) {
        while (j > 0 && pattern.charAt(i) != pattern.charAt(j)) j = table[j-1];
        if (pattern.charAt(i) == pattern.charAt(j)) table[i] = ++j;
    }
    return table;
}

33. Permutations / Combinations / Bitmask

// Bitmask Combination
for (int mask = 0; mask < (1 << N); mask++) {
    for (int i = 0; i < N; i++) {
        if ((mask & (1 << i)) != 0) {
            // element i is selected
        }
    }
}

34. BigInteger / BigDecimal

BigInteger a = new BigInteger("12345678901234567890");
BigInteger b = new BigInteger("98765432109876543210");
BigInteger sum = a.add(b);
BigDecimal dec = new BigDecimal("1234.5678");
BigDecimal result = dec.setScale(2, RoundingMode.HALF_UP);

출처 : chatGPT


Java 배열 관련 주요 메서드 정리

1. 배열 비교: Arrays.equals()

Arrays.equals(array1, array2);

설명

내용

비교 대상

두 배열의 크기와 요소 값을 모두 비교

반환값

true(같음), false (다름)

주의

== 또는.equals()는 배열 주소 비교이므로 사용 ❌

🔍 예시:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(Arrays.equals(a, b)); // ✅ true
System.out.println(a == b);              // ❌ false (주소 비교)

2. 배열 복사: Arrays.copyOf()

Arrays.copyOf(원본배열, 복사할길이);

원본 배열의 앞에서부터 지정한 길이만큼 복사하여 새 배열을 생성한다.
반환값은새로운 배열이고, 원본과 별개의 객체이다.

🔍 예시:

int[] original = {1, 2, 3, 4};
int[] copied = Arrays.copyOf(original, 2);  // [1, 2]

✨ 확장 사용: 길이 초과 시 0으로 채움

int[] extended = Arrays.copyOf(original, 6);  // [1, 2, 3, 4, 0, 0]

3. 부분 복사: Arrays.copyOfRange()

Arrays.copyOfRange(배열, 시작인덱스, 끝인덱스);

시작 인덱스부터 끝 인덱스 전까지 복사한다.

반환값은 새로운 배열 (구간 복사)이다.

한 마디로 배열의 슬라이싱을 구현한다.

🔍 예시:

int[] sub = Arrays.copyOfRange(original, 1, 3);  // [2, 3]

4. 배열 정렬: Arrays.sort()

Arrays.sort(배열);

배열을 오름차순 정렬할 때 쓴다. (in-place 정렬, 반환값 없음 void)

void타입을 반환하기 때문에 새로운 변수에 담을 수 없다.

정렬 기준(숫자: 오름차순, 문자열: 유니코드 기준)

🔍 예시:

int[] arr = {5, 1, 3};
Arrays.sort(arr);  // arr → [1, 3, 5]

5. 배열 출력: Arrays.toString()

Arrays.toString(배열);

배열의 내용을 문자열로 출력한다. (디버깅용)

🔍 예시:

System.out.println(Arrays.toString(arr)); // [1, 3, 5]

6. 배열 채우기: Arrays.fill()

Arrays.fill(배열, 값);

모든 요소를 동일한 값으로 초기화한다.

🔍 예시:

int[] arr = new int[5];
Arrays.fill(arr, 7); // arr → [7, 7, 7, 7, 7]

7. 배열 이진 탐색: Arrays.binarySearch()

Arrays.binarySearch(정렬된배열, 찾을값);

정렬된 배열에서 이진 탐색을 수행한다.
반환값은 인덱스이다. (없으면 음수)

🔍 예시:

int[] sorted = {1, 2, 3, 4};
int idx = Arrays.binarySearch(sorted, 3); // 2

✅ 요약

기능

메서드

배열 내용 비교

Arrays.equals()

전체 복사

Arrays.copyOf()

부분 복사

Arrays.copyOfRange()

배열 정렬

Arrays.sort()

배열 출력

Arrays.toString()

배열 초기화

Arrays.fill()

이진 탐색

Arrays.binarySearch

✅ 코테에서 자주 쓰는 조합

상황

추천 조합

두 문자열이 같은 문자로 이루어졌는지 확인

toCharArray() → Arrays.sort() → Arrays.equals()

원본 배열 유지하며 정렬

Arrays.copyOf() + Arrays.sort()

배열 슬라이스

Arrays.copyOfRange()



Java 표현식(Expression)

1. 표현식이란?

**표현식(Expression)**이란, 값을 생성하는 코드 조각이다.
변수, 상수, 연산 결과, 객체 생성 등 결과값이 나오는 모든 코드가 표현식이다

2. 예시로 보는 표현식

코드

결과

설명

3 + 4

7

정수 덧셈

"Hi" + " there"

"Hi there"

문자열 연결

new String("abc")

"abc"

객체 생성

arr.length

배열 길이

배열의 길이 참조

x > 5

true/false

비교 연산

3. 표현식과 문장(statement)의 차이

// 표현식
3 + 4               // 값: 7
"Hello" + "World"   // 값: "HelloWorld"
x > 5               // 값: true 또는 false

// 문장
int a = 3 + 4;               // 변수 선언 (할당)
System.out.println("Hi");   // 메서드 호출
if (x > 5) { ... }           // 조건문

4. 표현식이 쓰이는 위치

위치

예시

return 문

return x + y;

변수 대입

int z = x * 2;

조건문 조건

if (a > b)

메서드 인자

System.out.println("Hi");

5. 요약


Java 이스케이프 시퀀스 (Escape Sequences)

1. 이스케이프 시퀀스란?

이스케이프 시퀀스는 일반 문자처럼 출력할 수 없는 특수한 동작(예: 줄바꿈, 탭 등)을
문자열 안에서 표현할 수 있도록 해주는 백슬래시 \로 시작하는 문자 조합이다.

2. 주요 이스케이프 시퀀스 표

이스케이프

의미

설명 예시

\n

줄바꿈 (newline)

줄을 바꿔줌

\t

탭 (tab)

띄어쓰기 4~8칸 (탭 위치에 따라 다름)

\"

큰따옴표 (")

문자열 안에서 큰따옴표 출력 가능

\'

작은따옴표 (')

작은따옴표를 문자 또는 문자열 안에서 사용

\\

백슬래시 ()

역슬래시 자체 출력

\r

캐리지 리턴 (CR)

커서를 맨 앞으로 이동 (거의 사용 안 함)

\b

백스페이스

이전 문자 삭제 (거의 사용 안 함)

\f

폼 피드 (Form feed)

페이지 넘김 (프린터 제어용, 현재는 거의 사용 안 함)

3. 사용 예시 코드

public class EscapeExample {
    public static void main(String[] args) {
        System.out.println("이름\t나이\t성별");
        System.out.println("철수\t20\t남");
        System.out.println("그는 말했다: \"안녕하세요\"");
        System.out.println("C:\\Program Files\\Java");
    }
}

출력 결과:

이름	나이	성별
철수	20	남
그는 말했다: "안녕하세요"
C:\Program Files\Java

4. 사용예시 

System.out.println("Hello\nWorld");  // 줄바꿈
char quote = '\'';                   // 작은따옴표 문자


Java 고급 출력 포맷 (이스케이프 시퀀스, printf, format)

1. 이스케이프 시퀀스란?

**이스케이프 시퀀스(Escape Sequence)**는 문자열 내에서 특수한 동작(줄바꿈, 탭, 따옴표 등)을 표현하기 위한 문자 조합이다.
Java에서는 \ 백슬래시로 시작한다.

1.1 주요 이스케이프 시퀀스

이스케이프

의미

예시 출력

\n

줄바꿈

줄을 바꿈

\t

탭

띄어쓰기(보통 4~8칸)

\"

큰따옴표 출력

"그는 말했다: \"안녕\""

\'

작은따옴표 출력

'I\'m fine'

\\

백슬래시 출력

"C:\\Users\\Dain"

\r

캐리지 리턴

커서를 맨 앞으로 이동 (거의 안 씀)

\b

백스페이스

글자 하나 삭제 (거의 안 씀)

\f

폼 피드

페이지 넘김 (거의 안 씀)

1.2 사용 예시

System.out.println("이름\t나이");
System.out.println("영희\t25");
System.out.println("그는 말했다: \"안녕하세요\"");
System.out.println("C:\\Program Files\\Java");

출력 결과:

이름    나이
영희    25
그는 말했다: "안녕하세요"
C:\Program Files\Java

2. 문자열 포맷 서식 문자

Java에서 문자열을 정해진 형식으로 출력하고 싶을 때 System.out.printf() 또는 String.format()을 사용한다.

2.1 기본 형식

System.out.printf("형식", 값1, 값2...);
String result = String.format("형식", 값1, 값2...);

2.2 주요 서식 문자

서식 문자

설명

예시 출력

%s

문자열

"이름: %s" → 이름 출력

%d

정수 (10진수)

"나이: %d"

%f

실수 (소수점 가능)

"점수: %.2f"

%c

문자

"성별: %c"

%n

줄바꿈 (OS별 호환)

"다음 줄%n"

%%

퍼센트(%) 출력

"100%% 완료"

2.3 자리수/정렬 설정

형식

설명

%5d

전체 5자리, 오른쪽 정렬

%-5d

전체 5자리, 왼쪽 정렬

%05d

앞자리를 0으로 채움 (총 5자리)

%.2f

소수점 둘째자리까지 출력

%6.2f

전체 6칸 중 소수점 2자리 포함

2.4 사용 예시

String name = "영희";
int age = 25;
double score = 93.756;

System.out.printf("이름: %s, 나이: %d%n", name, age);
System.out.printf("점수: %.2f%n", score);
System.out.printf("진행률: %d%%%n", 100);

출력 결과:

이름: 영희, 나이: 25
점수: 93.76
진행률: 100%

3. 요약 비교표

항목

예시

설명

이스케이프 문자

\n, \t, \\

문자열 내부 제어

서식 문자 (printf)

%d, %.2f, %s

형식을 지정하여 출력

4. 콘솔 색상 출력 (ANSI 컬러)

Java 자체는 콘솔 색상 기능을 제공하지 않지만, 터미널에서 ANSI 코드를 사용하면 출력 색을 변경할 수 있다.

public class ColorExample {
    public static final String RED = "\u001B[31m";
    public static final String RESET = "\u001B[0m";

    public static void main(String[] args) {
        System.out.println(RED + "이 문장은 빨간색입니다." + RESET);
    }
}

색상

ANSI 코드

빨강

\u001B[31m

초록

\u001B[32m

노랑

\u001B[33m

파랑

\u001B[34m

리셋

\u001B[0m

5. 날짜 및 시간 포맷 출력

Java에서는 java.time.LocalDateTime과 DateTimeFormatter를 사용해 날짜/시간을 원하는 형식으로 출력할 수 있다.

5.1 DateTimeFormatter 기본 사용

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

LocalDateTime now = LocalDateTime.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println("현재 시간: " + now.format(fmt));

5.2 주요 포맷 패턴

패턴

의미

예시

yyyy

연도

2025

MM

월

05

dd

일

22

HH

시간 (24시간제)

14

hh

시간 (12시간제)

02

mm

분

07

ss

초

59

a

오전/오후

AM

/

PM

E

요일

Wed

5.3 사용자 지정 포맷 예시

DateTimeFormatter customFmt = DateTimeFormatter.ofPattern("yyyy년 MM월 dd일 (E) a hh:mm");
String formatted = now.format(customFmt);
System.out.println("형식화된 시간: " + formatted);

6. 로깅용 포맷 출력

Java에는 기본 로그 시스템인 java.util.logging.Logger가 있다.

6.1 Logger 기본 사용

import java.util.logging.*;

Logger logger = Logger.getLogger("MyLogger");

logger.info("정보 메시지");
logger.warning("경고 메시지");
logger.severe("에러 메시지");

6.2 포맷 문자열과 함께 쓰기

String name = "다인";
int age = 25;
logger.info(String.format("사용자 이름: %s, 나이: %d", name, age));

6.3 로그 레벨 종류

레벨

설명

SEVERE

심각한 오류

WARNING

경고

INFO

일반 정보

CONFIG

설정 관련 정보

FINE

디버깅 수준의 정보

6.4 출력 형식 커스터마이징


Java 정규식(Regular Expression)

1. 개요

정규표현식(Regular Expression)은 특정 문자열을 패턴에 맞게 검색, 대체, 검증하는 데 사용되는 강력한 도구이다. 자바에서는 java.util.regex 패키지를 통해 정규표현식을 사용할 수 있다.

1.1. 정규표현식 구성 요소

정규표현식은 기본적인 문법과 특수 문자를 조합하여 만들어지며, 자주 사용되는 몇 가지 주요 구성 요소가 있다.

1.2. 자주 사용되는 패턴

2. 자바에서 정규표현식 사용하기

2.1. Pattern 클래스

Pattern 클래스는 정규표현식의 패턴을 컴파일하는 데 사용된다. 이 클래스는 정규표현식 패턴을 매칭하고 검색하는 방법을 제공한다.

2.1.1. Pattern 컴파일

Pattern pattern = Pattern.compile("a*b");

위의 코드에서 "a*b"는 'a'가 0번 이상 반복되고 뒤에 'b'가 오는 패턴을 의미한다.

2.1.2. Matcher 클래스 사용

Matcher 클래스는 Pattern 객체를 사용하여 문자열과의 매칭을 처리한다.

Pattern pattern = Pattern.compile("a*b");
Matcher matcher = pattern.matcher("aaab");
boolean matches = matcher.matches(); // true

2.2. Pattern과 Matcher의 주요 메서드

3. 정규표현식 활용 예시

3.1. 이메일 주소 검증

이메일 주소가 유효한지 검사하는 정규표현식 예시

Pattern pattern = Pattern.compile("^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$");
Matcher matcher = pattern.matcher("example@domain.com");
boolean isValid = matcher.matches(); // true

3.2. 전화번호 형식 검증

전화번호 형식이 맞는지 검사하는 정규표현식 예시

Pattern pattern = Pattern.compile("^\\d{3}-\\d{3,4}-\\d{4}$");
Matcher matcher = pattern.matcher("010-1234-5678");
boolean isValid = matcher.matches(); // true


Java Arrays.sort() 정리

1. 개요

2. 기본 문법

Arrays.sort(배열);

매개변수

설명

배열

정렬 대상 (예: int[], char[], String[])

3. 반환값이 void인 이유

항목

설명

제자리 정렬

Arrays.sort()는 원본 배열 자체를 수정함

새로운 배열 반환 안 함

정렬된 배열을 새로 만들어 반환하지 않음

메모리 절약

불필요한 배열 복사 없이 빠른 정렬 수행 가능

할당 X

int[] sorted = Arrays.sort(arr); ❌ 오류 발생

4. 예시

int[] numbers = {3, 1, 4};
Arrays.sort(numbers);  // numbers 자체가 정렬됨

System.out.println(Arrays.toString(numbers)); // [1, 3, 4]

5. 흔한 실수 예시 ❌

int[] sorted = Arrays.sort(numbers); // ❌ 컴파일 에러: void를 int[]에 대입할 수 없음

6. 대안: 정렬된 배열을 새로 만들고 싶다면?

int[] original = {3, 1, 2};
int[] copy = Arrays.copyOf(original, original.length);
Arrays.sort(copy);

7. 관련 메서드

메서드

설명

Arrays.sort(arr)

기본 오름차순 정렬

Arrays.sort(arr, Comparator)

사용자 정의 기준 정렬 (객체 배열)

Collections.sort(list)

리스트 정렬 (반환값 없음)