자바 코딩테스트 오답정리

문자열

1. [Java] 암호 해독 - cipher.charAt(i - 1)
2. [Java] 대문자와 소문자
3. [Java] 영어가 싫어요 - numbers.replaceAll(a,b);
4. [Java] 인덱스 바꾸기 - return new String(arr);
5. [Java] 한 번만 등장한 문자 (문자열) - sb.toString();
10. [Java] 숫자 찾기 - String.indexOf(), String.valueOf()

배열

6. [Java] 약수구하기 - list.toArray(new String[0]);
7. [Java] 가장 큰 수 찾기- return new int[]{max, idx};
8. [Java] 문자열 계산하기 - Character.isDigit(c)
9. [Java] 배열의 유사도(배열, Set) - set.contains(str)
11. [Java] 삼각형의 완성조건(2): case2는 왜 longer - shorter인가?

Java Coding Test Cheatsheet
Java 표현식(Expression)이 뭐야?
Java 이스케이프 시퀀스 (Escape Sequences)
Java 고급 출력 포맷 (이스케이프 시퀀스, printf, format)
Java 정규식(Regular Expression)
Java Arrays.sort() 정리
Java 배열 관련 주요 메서드 정리

문자열

1. [Java] 암호 해독 - cipher.charAt(i - 1)

https://school.programmers.co.kr/learn/courses/30/lessons/120892

오답

class Solution {
    public String solution(String cipher, int code) {
        StringBuilder sb = new StringBuilder();
        for (int i = code; i <= cipher.length(); code++;) {
            sb.append(cipher[i-1]); // 인덱스는 0부터 시작
        }
        return sb.toString();
    }
}

✅ for문의 증가식 오류

for (int i = code; i <= cipher.length(); code++;)

→ code++→ 증가식 자리에 있어야 할 변수는 i (반복 제어 변수)
→ code++는 code 값을 계속 바꿔버려서 논리적으로도 틀림

✅ 문자열 인덱스 접근 오류

Java에서 문자열은 []로 접근 불가 → charAt(index) 사용해야 함

정답 코드

class Solution {
    public String solution(String cipher, int code) {
        StringBuilder sb = new StringBuilder();
        for (int i = code; i <= cipher.length(); i += code) {
            sb.append(cipher.charAt(i - 1)); // 인덱스는 0부터 시작
        }
        return sb.toString();
    }
}

문자열

2. [Java] 대문자와 소문자

https://school.programmers.co.kr/learn/courses/30/lessons/120893

오답

class Solution {
    public String solution(String my_string) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < my_string.length(); i++) {
            if(Character.isUpperCase((my_string.charAt(i)))) {
                sb.append(Character.toLowerCase(my_string.charAt(i)));
            } else {
                sb.append(Character.toUpperCase(my_string.charAt(i)));
            }
        }
        return sb.toString();
    }
}

✅ my_string.charAt(i)는 위로 빼서 char c = my_string.charAt(i); 로 만들어 주면 코드가 간단해진다.

개선한 코드

class Solution {
    public String solution(String my_string) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < my_string.length(); i++) {
            char c = my_string.charAt(i);
            if(Character.isUpperCase(c)) {
                sb.append(Character.toLowerCase(c));
            } else {
                sb.append(Character.toUpperCase(c));
            }
        }
        return sb.toString();
    }
}

문자열

3. [Java] 영어가 싫어요 - numbers.replaceAll(a,b);

https://school.programmers.co.kr/learn/courses/30/lessons/120894

틀린 코드

class Solution {
    public long solution(String numbers) {
        String[] words = {
            "zero", "one", "two", "three", "four", "five",
            "six", "seven", "eight", "nine"
        };
        for (int i = 0; i < words.length; i++) {
            numbers = numbers.replace(words[i], String.valueOf(i));
        }
        return Integer.parseInt(numbers);
    }
}

테스트는 통과했으나 답안 제출시 런타임 에러

✅ Integer.parseInt() 사용 시 런타임 에러

만약 숫자 문자열이 int의 범위를 초과하면 런타임 에러가 발생한다.
그래서 일부 테스트 케이스에서 에러가 난 것
예를 들어서, 만약 13자리 숫자가 들어오면 int(32비트 정수)의 최대값 2,147,483,647을 초과함
→ Integer.parseInt()는 처리 못 함 → 런타임 에러 (NumberFormatException) 발생
따라서 return 타입을 int가 아니라 long 타입으로 변경해야 한다.

개선한 코드

class Solution {
    public long solution(String numbers) {
        String[] words = {
            "zero", "one", "two", "three", "four", "five",
            "six", "seven", "eight", "nine"
        };
        for (int i = 0; i < words.length; i++) {
            numbers = numbers.replaceAll(words[i], String.valueOf(i));
        }
        return Long.parseLong(numbers); // ✅ int → long 으로 변경
    }
}

기본형 VS 래퍼클래스

✅ 기본형 (Primitive type)

int → 기본형 정수 타입 (primitive int)
long → 기본형 정수 타입 (primitive long)

👉 메모리에 값 자체를 저장함
👉 성능이 빠르고 메모리 사용이 효율적

✅ 참조형 (Reference type, Wrapper class)

Integer → 참조형 (래퍼 클래스, Wrapper class for int)
Long → 참조형 (래퍼 클래스, Wrapper class for long)

👉 객체이기 때문에 null 값을 가질 수 있음
👉 ArrayList<Integer>처럼 제네릭에 사용 가능
👉 기본형은 제네릭에서 사용할 수 없음 → 참조형 필요

문자열

4. [Java] 인덱스 바꾸기 - return new String(arr);

https://school.programmers.co.kr/learn/courses/30/lessons/120895

틀린 코드

class Solution {
    public String solution(String my_string, int num1, int num2) {
        String[] arr = String.toCharArray(my_string);
        char tmp = arr[num1];
        arr[num1] = arr[num2];
        arr[num2] = tmp;
        return arr.toString();
    }
}

✅ String[] arr = String.toCharArray(my_string);

→ String.toCharArray()는 char[]를 리턴하므로 타입은 String[]이 아니라 char[]이어야 한다.

✅ String.toCharArray() 용법

→ my_string.toCharArray();
toCharArray()는 String 클래스의 인스턴스 메서드이다.
그래서 String.toCharArray() ❌ (클래스 메서드 아님)
반드시 인스턴스(my_string)에 붙여야 한다.

✅ return arr.toString();

char[]에서 toString()을 쓰면 주소값이 출력된다.
→ 대신 new String(arr)을 사용해야 문자열로 출력된다.

개선한 코드

class Solution {
    public String solution(String my_string, int num1, int num2) {
        char[] arr = my_string.toCharArray();
        char tmp = arr[num1];
        arr[num1] = arr[num2];
        arr[num2] = tmp;
        return new String(arr);
    }
}

클래스 메서드 VS 인스턴스 메서드

자바에서 메서드는 크게 인스턴스 메서드와 **클래스 메서드(static 메서드)**로 나뉘는데, 이 둘은 메서드를 어떻게 호출하고 언제 사용하는지에 따라 중요한 차이를 가진다.

클래스 메서드는 static 키워드로 정의되어 있어 객체를 만들지 않아도 클래스 이름으로 바로 호출할 수 있는 메서드이다. 클래스 메서드는 객체의 고유 상태와는 무관하며, 보통 모든 인스턴스에서 공통으로 사용하는 로직을 구현할 때 사용됩니다. 대표적인 예로 Integer.parseInt("123")는 문자열을 정수로 변환하는 클래스 메서드로, Integer라는 클래스 이름만으로 바로 호출할 수 있다.

반면 인스턴스 메서드는 특정 객체가 생성되어야만 사용할 수 있는 메서드이다. 즉, new 키워드로 객체를 만든 후에야 호출이 가능하며, 주로 그 객체의 상태(멤버 변수)를 기반으로 동작한다. 예를 들어, str.length()는 문자열 객체 str의 길이를 반환하는 인스턴스 메서드인데, 이는 str이라는 객체가 존재해야만 호출할 수 있다.

인스턴스 메서드는 객체마다 상태가 다를 수 있기 때문에, 같은 메서드를 호출하더라도 객체에 따라 결과가 달라진다. 예를 들어, Person이라는 클래스에 sayHello()라는 인스턴스 메서드가 있다면, person1.sayHello()와 person2.sayHello()는 각각 다른 이름을 출력한다. 이는 각 인스턴스가 가지고 있는 name 값이 다르기 때문이다.

이처럼 인스턴스 메서드는 객체의 고유한 데이터를 다루고 조작할 때 유용하며, 클래스 메서드는 그와 무관한 공통 기능을 제공할 때 사용된다. 개발자는 기능의 목적에 따라 두 메서드 중 적절한 쪽을 선택해야 한다. 객체마다 달라지는 동작이 필요하다면 인스턴스 메서드, 객체 없이 호출해도 되는 범용적인 기능이라면 클래스 메서드를 사용하는 것이 좋다.

✅ 1. 인스턴스 메서드 (Instance Method)

정의

객체를 생성해야 호출할 수 있는 메서드
객체의 상태(필드 값)에 따라 동작이 달라질 수 있음

특징

new 키워드로 인스턴스를 만든 후 사용
보통 객체 내부의 데이터를 다룰 때 사용됨

예시

public class Person {
    String name;

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

// 사용
Person p = new Person();
p.name = "Dain";
p.sayHello();  // 출력: Hello, my name is Dain

✅ 2. 클래스 메서드 (Class Method)

정의

객체 생성 없이 호출 가능한 메서드
static 키워드로 정의됨

특징

클래스 이름으로 직접 호출 가능
객체의 상태와 무관하게 동작함
보통 공통 기능, 유틸리티 기능 등에 사용됨

예시

public class MathUtil {
    public static int add(int a, int b) {
        return a + b;
    }
}

// 사용
int result = MathUtil.add(3, 5);  // 객체 없이 호출 가능

문자열

5. [Java] 한 번만 등장한 문자 (문자열) - sb.toString();

https://school.programmers.co.kr/learn/courses/30/lessons/120896

틀린 코드

import java.util.*;

class Solution {
    public String solution(String s) {
        int[] cnt = new int[26];
        
        for(char c : s.toCharArray()) {
            cnt[c - 'a']++;
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 26; i++) {
            if (cnt[i] == 1) sb.append((char)i+'a');
        }
        return sb.toString(); 
    }
}

✅ sb.append((char)i + 'a');

이 int를 char 타입으로 형변환하려는 의도지만, 실제로는 그냥 int로 연산된다.
예를 들어, i = 0일 때 char는 연산 시 int로 자동 변환되므로 → 0 + 97

(char)i + 'a' // => 정수 + 정수 → int로 연산됨

→ i + 'a' 전체를 char로 캐스팅해야 문자로 제대로 변환된다.

sb.append((char)(i + 'a'));

개선한 코드

import java.util.*;

class Solution {
    public String solution(String s) {
        int[] cnt = new int[26];
        
        for(char c : s.toCharArray()) {
            cnt[c - 'a']++;
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 26; i++) {
            if (cnt[i] == 1) sb.append((char)(i + 'a'));
        }
        return sb.toString(); 
    }
}

문자열

10. [Java] 숫자 찾기 - String.indexOf(), String.valueOf()

https://school.programmers.co.kr/learn/courses/30/lessons/120904

틀린 코드

class Solution {
    public int solution(int num, int k) {
        String numToString = Integer.toString(num);
        char[] arr = numToString.toCharArray();
        char kToChar = (char) k; 
        int idx = -1;
        for(int i = 0; i < arr.length; i++ ) {
            if (arr[i] == kToChar) {
                return i+1;
            }
        }
        return idx;
    }
}

✅ char kToChar = (char) (k + '0');

틀린 부분: char kToChar = (char) k;
int 타입을 char 타입으로 변환하는 방법이 잘못됨
→ int 3을 (char)로 바꾸면 '3'이 아니라 아스키 문자 'ETX' 같은 이상한 문자가 됨
→ char kToChar = (char)(k + '0'); 또는 Character.forDigit(k, 10); 로 고쳐야 함

개선한 코드

class Solution {
    public int solution(int num, int k) {
        String numToString = Integer.toString(num);
        char[] arr = numToString.toCharArray();
        char kToChar = (char) (k + '0');
        int idx = -1;
        for(int i = 0; i < arr.length; i++ ) {
            if (arr[i] == kToChar) {
                return i+1;
            }
        }
        return idx;
    }
}

더 간단한 방법 (String API 활용)

public int solution(int num, int k) {
    String s = String.valueOf(num);
    int idx = s.indexOf(String.valueOf(k));
    return idx == -1 ? -1 : idx + 1;
}

✅ String.indexOf()

문자열 내에서 특정 문자나 문자열이 처음 등장하는 위치의 인덱스를 알려주는 매우 유용한 메서드이다.

📌 기본 사용법

String s = "29183";
int idx = s.indexOf("1");   // 결과: 2

문자열 "1"이 "29183"에서 0-based index 2에 처음 등장
못 찾으면 -1을 반환

📌 자바 공식 문법

int indexOf(int ch)           // 문자 또는 문자 코드 (ex: 'a', 97)
int indexOf(String str)       // 문자열

✅ 삼항연산자

자바의 삼항 연산자(ternary operator)는 if-else를 한 줄로 간단하게 쓸 수 있게 해주는 조건 연산자이다.

📌 기본 사용법

조건식 ? 참일 때 값 : 거짓일 때 값;

조건식이 true이면 ? 다음의 값을 반환
false이면 : 다음의 값을 반환

📌 예제

int age = 20;
String result = (age >= 18) ? "성인" : "미성년자";
System.out.println(result);  // 출력: 성인

배열

6. [Java] 약수구하기 - list.toArray(new String[0]);

https://school.programmers.co.kr/learn/courses/30/lessons/120897

틀린 코드

import java.util.*;

class Solution {
    public int[] solution(int n) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            if(n%i==0) list.append(i);
        }
        int[] answer = list.toArray(new String[0]);
        return answer;
    }
}

✅ for (int i = 0; i <= n; i++)

❗ i = 0일 때 n % 0은 ArithmeticException (0으로 나눌 수 없음!)
✅ 따라서 i = 1부터 시작해야 한다.

✅ list.add(i)

ArrayList에서 값을 추가할 때는 append()가 아니라 add()를 사용해야 한다.
list.append(i) → list.add(i)

✅ int[] answer = list.toArray(new String[0]);

List → Array 로 변환할때 참조형은 toArray() 메서드로 가능하지만 int 같은 기본형은 직접 변환할 수 없다.
직접 반복문을 돌려서 변환해야 한다.

개선한 코드

import java.util.*;

class Solution {
    public int[] solution(int n) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            if(n%i==0) list.add(i);
        }
        int[] answer = new int[list.size()];
        for(int i = 0; i < list.size(); i++) {
            answer[i] = list.get(i);
        }
        return answer;
    }
}

Stream 사용 버전

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] solution(int n) {
        return IntStream.rangeClosed(1, n) // 1부터 n까지 숫자 생성
                .filter(i -> n % i == 0)   // 약수만 필터링
                .toArray();                // int[]로 반환
    }
}

List → Array 형변환

List 타입	변환 방법
`List<String>`	`list.toArray(new String[0])`
`List<Integer>`	`list.toArray(new Integer[0])`
`List<Integer>` → `int[]`	반복문으로 수동 변환 필요

✅ 1. List → Array (참조형, 예: Integer, String 등)

toArray() 메서드로 변환이 가능하다.

List<String> list = Arrays.asList("a", "b", "c");
String[] arr = list.toArray(new String[0]);

list.toArray(new String[0]): 타입을 명시한 배열로 변환
new String[0]은 사이즈가 0이어도 자동으로 맞춰준다.

List<Integer> list = Arrays.asList(1, 2, 3);
Integer[] arr = list.toArray(new Integer[0]);

✅ 2. List → Array (기본형, 예: int)

Java의 List<Integer>는 int[]로 직접 변환 불가능
직접 반복문으로 넣어줘야 한다.

List<Integer> list = Arrays.asList(1, 2, 3);
int[] arr = new int[list.size()];

for (int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);  // 언박싱 자동 수행
}

Array → List 형변환

	변환 방법
`String[]`	`Arrays.asList(arr)`
`Integer[]`	`Arrays.asList(arr)`
`int[]`	Arrays.stream(arr).boxed().collect(Collectors.toList())

✅ 1. 참조형 배열 → List (예: String[], Integer[] 등)

String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr);

Arrays.asList()는 배열을 고정 크기 리스트로 바꿔준다.
추가/삭제는 불가능 → 변경 가능한 리스트로 바꾸려면

List<String> modifiableList = new ArrayList<>(Arrays.asList(arr));

✅ 2. 기본형 배열 → List (예: int[], double[] 등)

자바의 int[]는 바로 List<Integer>로 바꿀 수 없다.
Stream + boxed()를 활용한다.

int[] arr = {1, 2, 3, 4};

List<Integer> list = Arrays.stream(arr)  // IntStream 생성
                           .boxed()      // int → Integer (박싱)
                           .collect(Collectors.toList());

배열

7. [Java] 가장 큰 수 찾기- return new int[]{max, idx};

https://school.programmers.co.kr/learn/courses/30/lessons/120899

틀린 코드

import java.util.*;

class Solution {
    public int[] solution(int[] array) {
        Arrays.sort(array);
        int[] answer = new int[2];
        answer[0] = array[array.length-1];
        answer[1] = array.length-1;
        return answer;
    }
}

✅ index 계산 잘못됨

array[array.length-1]는 정렬된 배열에서 최댓값이 맞지만, array.length-1은 최댓값의 원래 인덱스가 아님.
배열을 오름차순 정렬해버리면, 원래 배열에서 최댓값의 인덱스는 사라진다.
따라서 최댓값을 담을 변수 max, 인덱스를 담을 변수 idx를 선언하고 반복문을 돌려 최댓값과 인덱스를 갱신한 후, 두 변수를 배열로 변환해서 반환한다.

개선한 코드

import java.util.*;

class Solution {
    public int[] solution(int[] array) {
        int max = array[0];
        int idx = 0;
        
        for(int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
                idx = i;
            }
        }
        return new int[]{max, idx};
    }
}

배열 리터럴을 반환할 때 쓰는 코드

int형 두 개짜리 배열을 직접 생성하고, 그 배열을 메서드의 반환값으로 사용하는 코드이다.

return new int[]{max, idx};

아래와 같이 배열을 만들고 반환하는 코드인데 한 줄로 줄인 것이다.

int[] result = new int[]{max, idx};
return result;

Java에서 return은 값을 반환하기만 하면 되기 때문에, 굳이 int[] result = ...처럼 중간에 변수에 담을 필요가 없다.

배열 리터럴은 선언 없이 쓰면 컴파일 오류가 난다.

int[] a;
a = {1, 2}; // ❌ 컴파일 오류

→ 대신 이렇게 써야 한다.

int[] a = new int[]{1, 2};

배열

8. [Java] 문자열 계산하기 - Character.isDigit(c)

https://school.programmers.co.kr/learn/courses/30/lessons/120902

틀린 코드 (1차 시도)

class Solution {
    public int solution(String my_string) {
        char[] arr = my_string.toCharArray();
        int sum = 0;
        for (char c : arr ) {
            if (c != '+' && c != '-' && c !=' ') {
                sum+= Integer.parseInt(c);
            }
        }
        return sum;
    }
}

✅ Integer.parseInt()

String을 int형으로 변환하는 코드를 써서 에러가 났다.
char타입을 정수로 변환할 때는 Integer.parseInt() 대신 char 타입 변수에 - '0'을 한다. (ASCII 코드)

String → int VS char → int

1. String을 int로 변환할 때는 Integer.parseInt()

String str = "123";

// 문자열 → int
int num = Integer.parseInt(str);       // 123

2. char을 숫자로 변환할 때는 char 타입 변수 - '0'

char c = '7';

// 문자 → 숫자 (정수값)
int digit = c - '0';   // '7' - '0' = 7

틀린 코드 (2차 시도)

class Solution {
    public int solution(String my_string) {
        char[] arr = my_string.toCharArray();
        int sum = 0;
        for (char c : arr ) {
            if (c != '+' && c != '-' && c !=' ') {
                sum+= c - '0';
            }
        }
        return sum;
    }
}

내가 쓴 코드는 모든 숫자를 "한 자리 숫자"로 처리한다. 즉, "12"가 있으면 1 + 2 = 3으로 계산한다.

String my_string = "a12b3";
→ arr = ['a', '1', '2', 'b', '3']
→ 결과: 1 + 2 + 3 = 6 (❗ 실제 12 + 3이 아님)

문제에서 원하는 것은 만약 "12 + 3" → 15로 계산하는 것이다.

String num 변수를 밖으로 빼고, Character.isDigit() 으로 c가 0~9사이 숫자형 문자열이면 num에 저장하는 형식으로 코드를 짜 주었다.

틀린 코드 (3차 시도)

class Solution {
    public int solution(String my_string) {
        char[] arr = my_string.toCharArray();
        int sum = 0;
        String num = "";
        for (char c : arr ) {
            if (Character.isDigit(c)) {
                num += c;
            } else {
                if (!num.isEmpty()) {
                    sum += Integer.parseInt(num);
                    num = ""; 
                }
            }
        }
        if (!num.isEmpty()) {
            sum += Integer.parseInt(num);
        }
        return sum;
    }
}

덧셈만 하는게 아니라 뺄셈도 있었다. 연산자(+, -)에 따라 연산을 모두 처리하는 코드를 짜야 한다.

문자열을 " "(공백) 기준으로 나눠서
처음 값은 result에 저장
이후에는 연산자(+ 또는 -)와 숫자가 번갈아 등장
연산자에 따라 +면 더하고, -면 빼야 함

틀린 코드 (4차 시도)

class Solution {
    public int solution(String my_string) {
        String[] splited = my_string.split(" ");
        int answer = Integer.parseInt(splited[0]);
        
        for(int i = 1; i < splited.length; i += 2) {
            String op = splited[i];
            int num = Integer.parseInt(splited[i + 1]);
            
            if (op == '+')) {
                answer += num;
            } else if (op == '-') {
                answer -= num;
            }
        }
        return answer;
    }
}

✅ if(op == '+')

이 코드는 컴파일 에러가 난다.
op는 String 타입으로 선언되었는데 '+'는 char로 타입이 달라서 비교 불가능하기 때문이다.
Java에서는 문자열 내용을 비교할 때 ==를 쓰지 않는다. ==는 두 객체가 같은 주소(참조)를 가리킬 때만 true이다.
내용 비교는 반드시 .equals()를 써야 한다.

개선한 코드

class Solution {
    public int solution(String my_string) {
        String[] splited = my_string.split(" ");
        int answer = Integer.parseInt(splited[0]);
        
        for(int i = 1; i < splited.length; i += 2) {
            String op = splited[i];
            int num = Integer.parseInt(splited[i + 1]);
            
            if (op.equals("+")) {
                answer += num;
            } else if (op.equals("-")) {
                answer -= num;
            }
        }
        return answer;
    }
}

배열

9. [Java] 배열의 유사도(배열, Set) - set.contains(str)

https://school.programmers.co.kr/learn/courses/30/lessons/120903

Set 을 활용한 코드

import java.util.*;

class Solution {
    public int solution(String[] s1, String[] s2) {
        Set<String> set = new HashSet<>(Arrays.asList(s1));
        int cnt = 0;
        for (String str : s2) {
            if (set.contains(str)) cnt++;
        }
        return cnt; 
    }
}

✅ Set<String> set = new HashSet<>(Arrays.asList(s1));

Set은 중복을 허용하지 않고, 검색 속도가 빠르기 때문에 비교 대상인 s1을 Set으로 변환하면 s2의 각 원소가 포함되어 있는지 빠르게 확인할 수 있다.

이중 for문(반복문)을 사용한 코드

class Solution {
    public int solution(String[] s1, String[] s2) {
        int cnt = 0;
        for (int i = 0; i < s1.length; i++) {
            for (int j = 0; j < s2.length; j++) {
                if (s1[i].equals(s2[j])) {
                    cnt++;
                    break;
                }
            }
        }
        return cnt;
    }
}

중복 카운팅을 피하려면 break;를 해야 한다.
문자열끼리 내용 비교는 .equals() 메서드를 사용해야 한다 ( == 은 주소값 비교)

배열

11. [Java] 삼각형의 완성조건(2): case2는 왜 longer - shorter인가?

1. 문제 요약

https://school.programmers.co.kr/learn/courses/30/lessons/120868
프로그래머스 삼각형의 완성조건(2)
두 변이 주어졌을 때, 나머지 한 변 x가 삼각형이 될 수 있는 정수 개수를 구하는 문제
삼각형이 되기 위한 조건: 가장 긴 변 < 나머지 두 변의 합

2. 정수 범위 공식

x ∈ (longer - shorter, longer + shorter)
즉, 가능한 정수 x의 범위는
longer - shorter + 1 ≤ x ≤ longer + shorter - 1

코드

import java.util.*;
 
class Solution {
    public int solution(int[] sides) {
        Arrays.sort(sides); // 배열 오름차순 정렬
        int shorter = sides[0];
        int longer = sides[1];
        
        // case1: x가 가장 긴 변일 때 -> x < a + b
        int case1 = longer + shorter - 1; 
        
        // case2: x가 짧거나 중간인 경우 -> x > max - min
        int case2 = longer - shorter;
        
        return case1 - case2;
    }
}

3. 왜 `case2 = longer - shorter`인가?

case2는 가능한 x의 시작값이 아님
실제 시작값은 longer - shorter + 1
하지만 정수 개수를 계산할 때는 시작값 - 1을 기준으로 계산해야 하므로
case2 = longer - shorter로 설정하는 것이 정확함

4. 예시

입력: sides = [3, 6]
가능한 x: 4, 5, 6, 7, 8 → 총 5개
계산:
case1 = 3 + 6 - 1 = 8
case2 = 6 - 3 = 3
answer = 8 - 3 = 5 ✅

요약

case2는 정수 개수 계산용 보조값
실제 시작값보다 1 작게 설정되어야 하므로 +1이나 -1 필요 없음
수식 하나로 정확히 계산 가능
(shorter + longer - 1) - (longer - shorter)

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

Use BufferedReader & BufferedWriter
HashMap, HashSet, TreeMap, PriorityQueue
Always validate inputs
Use boolean[], Set, or visited[][] for visited states
Practice common patterns (DFS/BFS, DP, Greedy, Two Pointers)

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

Tail recursion is not optimized in Java.
Prefer loops for heavy stack recursion.
Consider memoization or iterative conversion.

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 표현식(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 출력 형식 커스터마이징

로그 출력 위치(콘솔/파일)
출력 메시지 포맷 (시간, 로그 레벨, 메시지 내용 등)
logging.properties 파일로 설정 변경 가능

Java 정규식(Regular Expression)

1. 개요

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

1.1. 정규표현식 구성 요소

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

문자 클래스: [ ]
- 예: [a-z]는 소문자 알파벳을 의미한다.
수량자: {n,m}, +, *, ?
- 예: a{2,4}는 'a'가 2번 이상 4번 이하 나타나는 패턴을 의미한다.
메타 문자: ^, $, ., |, \
- 예: ^abc는 'abc'로 시작하는 문자열을 의미한다.

1.2. 자주 사용되는 패턴

.: 임의의 한 문자 (개행 문자를 제외)
\d: 숫자 (0-9)
\w: 알파벳 및 숫자, 밑줄 (a-zA-Z0-9_)
\s: 공백 문자 (탭, 스페이스 등)
\b: 단어 경계

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`의 주요 메서드

matches(): 전체 문자열이 정규표현식에 맞는지 확인
find(): 패턴이 문자열 내에서 부분적으로 일치하는지 확인
replaceAll(): 일치하는 부분을 다른 문자열로 대체

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. 개요

Arrays.sort()는 Java에서 배열을 정렬할 때 사용하는 정적 메서드이다.
이 메서드는 배열을 제자리(in-place) 에서 정렬하며, 반환값이 없다 = (void를 반환한다.)

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)`	리스트 정렬 (반환값 없음)

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()`

자바 코딩테스트 오답정리

문자열

1. [Java] 암호 해독 - cipher.charAt(i - 1)

✅ for문의 증가식 오류

✅ 문자열 인덱스 접근 오류

2. [Java] 대문자와 소문자

3. [Java] 영어가 싫어요 - numbers.replaceAll(a,b);

✅ Integer.parseInt() 사용 시 런타임 에러

기본형 VS 래퍼클래스

✅ 기본형 (Primitive type)

✅ 참조형 (Reference type, Wrapper class)

4. [Java] 인덱스 바꾸기 - return new String(arr);

✅ String[] arr = String.toCharArray(my_string);

✅ String.toCharArray() 용법

✅ return arr.toString();

클래스 메서드 VS 인스턴스 메서드

✅ 1. 인스턴스 메서드 (Instance Method)

✅ 2. 클래스 메서드 (Class Method)

5. [Java] 한 번만 등장한 문자 (문자열) - sb.toString();

✅ sb.append((char)i + 'a');

10. [Java] 숫자 찾기 - String.indexOf(), String.valueOf()

✅ char kToChar = (char) (k + '0');

✅ String.indexOf()

✅ 삼항연산자

배열

6. [Java] 약수구하기 - list.toArray(new String[0]);

✅ for (int i = 0; i <= n; i++)

✅ list.add(i)

✅ int[] answer = list.toArray(new String[0]);

Stream 사용 버전

List → Array 형변환

✅ 1. List → Array (참조형, 예: Integer, String 등)

✅ 2. List → Array (기본형, 예: int)

Array → List 형변환

✅ 1. 참조형 배열 → List (예: String[], Integer[] 등)

✅ 2. 기본형 배열 → List (예: int[], double[] 등)

7. [Java] 가장 큰 수 찾기- return new int[]{max, idx};

✅ index 계산 잘못됨

8. [Java] 문자열 계산하기 - Character.isDigit(c)

✅ Integer.parseInt()

✅ if(op == '+')

9. [Java] 배열의 유사도(배열, Set) - set.contains(str)

✅ Set<String> set = new HashSet<>(Arrays.asList(s1));

11. [Java] 삼각형의 완성조건(2): case2는 왜 longer - shorter인가?

1. 문제 요약

2. 정수 범위 공식

3. 왜 case2 = longer - shorter인가?

4. 예시

요약

Java Coding Test Cheatsheet

0. Frequently Used Libraries

1. Variable & Array Declaration

2. Arrays Utility

3. length / length() / size()

4. String Handling

5. HashMap

6. ArrayList

7. Queue (LinkedList)

8. PriorityQueue

9. Math

10. HashSet

11. Stack

12. Deque (ArrayDeque)

13. TreeSet

14. TreeMap

15. Fast I/O

16. DFS

17. BFS

18. Sorting

19. DP (Fibonacci)

20. Union-Find

21. Bitmask

22. Greedy

23. Prefix Sum

24. Sliding Window

25. Sieve of Eratosthenes

26. Dijkstra

27. Tree / LCA

28. Coding Test Patterns

29. Backtracking (Permutation, Combination)

3. 왜 `case2 = longer - shorter`인가?

2.1. `Pattern` 클래스

2.2. `Pattern`과 `Matcher`의 주요 메서드

3. 반환값이 `void`인 이유

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

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

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

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

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

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

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

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