자바 이론


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 고급 출력 포맷 (이스케이프 시퀀스, 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() 반환값은 void

1. 개요

2. 기본 문법

Arrays.sort(배열);

매개변수

설명

배열

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

3. 반환값이 void인 이유

항목

설명

제자리 정렬

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

새로운 배열 반환 안 함

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

메모리 절약

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

할당 X

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

4. 정렬된 배열을 새로 만들고 싶다면?

아래와 같이 Arrays.copyOf(원본배열, 원본배열의 길이)를 통해 배열을 복사한 후, 정렬을 수행한다.

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

5. 관련 메서드

메서드

설명

Arrays.sort(arr)

기본 오름차순 정렬

Arrays.sort(arr, Comparator)

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

Collections.sort(list)

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