이럴 때 사용하는 자료구조가 바로 스택(Stack), 즉 LIFO(Last In, First Out) 구조입니다. 오늘은 자바에서 스택 로직을 구현할 때 흔히 하는 실수부터, 코딩 테스트를 통과하기 위한 최적화 방법, 그리고 자바 내장 클래스 활용법까지 3단계로 나누어 완벽하게 정리해 보겠습니다.

1단계: 초보자의 접근 (배열 크기 직접 조절하기)

가장 먼저 떠올릴 수 있는 방법은 기본 배열(int[])을 만들고, 데이터가 들어오거나 나갈 때마다 배열의 크기를 늘렸다 줄였다 하는 것입니다.

public int[] makeStack(int[] arr) {
    int[] stk = {}; // 빈 배열

    for(int num : arr) {
        // 넣을 때: 기존 배열을 복사해서 1칸 더 큰 배열을 만듦
        stk = Arrays.copyOf(stk, stk.length + 1);
        stk[stk.length - 1] = num; // 마지막 방(길이 - 1)에 넣기

        // 뺄 때: 마지막 칸을 제외하고 복사해서 배열을 줄임
        // stk = Arrays.copyOfRange(stk, 0, stk.length - 1); 
    }
    return stk;
}

• 문제점: 논리적으로는 완벽하지만, 코딩 테스트에서는 100% '시간 초과'가 발생합니다. * 이유: Arrays.copyOf는 단순히 크기만 바꾸는 게 아니라, 매번 새로운 배열을 메모리에 만들고 기존 데이터를 하나씩 다 옮겨 적는 무거운 작업이기 때문입니다. (마치 짐을 하나 추가할 때마다 더 큰 집으로 이사를 가는 것과 같습니다.)

2단계: 고수들의 퍼포먼스 (인덱스 포인터 활용)

배열을 매번 새로 만들지 않고 속도를 극한으로 끌어올리려면 어떻게 해야 할까요? 바로 "처음부터 가장 큰 집을 구해놓고, 손가락(인덱스)으로 현재 위치만 가리키는 방식"을 사용해야 합니다.

public int[] fastStack(int[] arr) {
    // 1. 처음부터 원본 길이만큼 넉넉한 배열을 딱 1번만 만듭니다.
    int[] stk = new int[arr.length]; 

    // 2. 현재 스택의 꼭대기를 가리키는 손가락(top 포인터)
    int top = 0; 

    for (int num : arr) {
        if (top == 0 || stk[top - 1] != num) { 
            // 다르면 넣는다 (현재 손가락 위치에 덮어쓰고 1칸 전진)
            stk[top] = num; 
            top++;          
        } else {
            // 같으면 뺀다 (손가락을 1칸 뒤로 무름 -> 다음에 알아서 덮어씌워짐)
            top--;          
        }
    }

    // 3. 마지막에 손가락이 가리키는 곳까지만 딱 1번 잘라서 반환!
    return Arrays.copyOf(stk, top); 
}

• 장점: 배열 복사를 맨 마지막에 딱 1번만 하므로 속도가 압도적으로 빠릅니다. 코딩 테스트에서 실행 속도를 줄이고 싶을 때 강력 추천하는 방식입니다.

3단계: 자바의 정석 (Stack 클래스 활용)

사실 자바에는 이미 이 모든 것을 알아서 해주는 Stack 클래스가 존재합니다! 크기가 알아서 늘어나고 줄어들기 때문에, 우리는 push(넣기), pop(빼기), peek(맨 위 확인)이라는 직관적인 단어만 사용하면 됩니다.

import java.util.Stack;
import java.util.Arrays;

public int[] standardStack(int[] arr) {
    Stack<Integer> stack = new Stack<>(); 

    for (int num : arr) {
        // 스택이 비어있지 않고, 맨 위 숫자(peek)가 현재 숫자와 같으면 뺀다(pop)!
        if (!stack.isEmpty() && stack.peek() == num) {
            stack.pop();
        } 
        // 아니면 넣는다(push)!
        else {
            stack.push(num);
        }
    }

    // (꿀팁) 만들어진 Stack을 int 배열로 한 줄에 변환하기!
    return stack.stream().mapToInt(i -> i).toArray();
}

• 장점: 코드가 마치 사람이 말하는 것처럼 직관적으로 읽히며, 자잘한 인덱스 에러(IndexOutOfBounds)에서 완전히 해방됩니다!

"  사과   바나나    포도 "

위 문자열처럼 맨 앞에 공백이 있거나, 단어 사이의 띄어쓰기 칸 수가 제멋대로인 문자열을 단순히 split(" ")으로 자르면 대참사가 발생합니다. 빈 문자열("")들이 배열에 불청객처럼 마구 끼어들기 때문이죠.

오늘은 이런 불규칙한 공백들을 단 한 줄의 코드로 완벽하게 제압하는 마법의 조합, trim()과 정규표현식([ ]+, \\s+)에 대해 파헤쳐 보겠습니다.

1단계: trim() - 앞뒤 쓰레기 공백 청소기

trim() 메서드는 문자열의 맨 앞(Leading)과 맨 뒤(Trailing)에 있는 의미 없는 공백들을 싹 지워주는 역할을 합니다. (단, 단어와 단어 '사이'에 있는 공백은 건드리지 않습니다.)

String text = "  안녕 하세요  ";
System.out.println(text.trim()); 
// 결과: "안녕 하세요"

왜 split을 하기 전에 trim()을 써야 할까요? 자바의 split은 문자열 맨 앞에 구분자(공백)가 있으면, *"어? 공백 앞에도 뭔가 글자가 있었나 본데?"* 하고 착각하여 배열의 첫 번째 방에 빈 문자열("")을 집어넣는 고질적인 특징이 있습니다. 따라서 split을 하기 전에 .trim()으로 맨 앞뒤 공백을 방어막처럼 미리 깎아내 주는 것이 안전합니다.

2단계: split("[ ]+") - 스페이스바 마스터

앞뒤 공백을 잘라냈다면, 이제 단어 사이에 있는 '제멋대로인 띄어쓰기'를 하나의 칼날로 잘라낼 차례입니다. 이때 사용하는 것이 바로 정규표현식(Regex)입니다.

String text = "사과   바나나  포도";
String[] arr = text.split("[ ]+");

• [ ] (대괄호): "이 안에 있는 글자를 찾아라!"라는 뜻입니다. 여기서는 스페이스바(공백) 한 칸이 들어있습니다.
• + (더하기): 정규표현식의 핵심 기호로, "앞의 글자가 1번 이상 연속으로 무한히 나올 수 있다"는 뜻입니다.

즉, "[ ]+"의 진짜 의미는 "스페이스바가 1칸이든, 3칸이든, 10칸이든 상관없이 하나로 뭉뚱그려서 잘라내라!"가 됩니다. 이 코드를 쓰면 빈 문자열 없이 딱 3개의 과일만 배열에 예쁘게 담깁니다.

3단계: split("\\s+") - 모든 공백의 지배자 (종결자)

• [ ]+도 훌륭하지만, 실무나 까다로운 코딩 테스트에서는 스페이스바 외에도 엔터(줄바꿈, \n)나 탭(Tab, \t) 키가 섞여 들어오는 경우가 아주 많습니다. 이때 [ ]+는 오직 '스페이스바'만 잡을 수 있기 때문에 탭이나 엔터를 만나면 자르지 못하고 에러를 유발합니다.

이 모든 상황을 평정하는 끝판왕이 바로 \\s+ 입니다.

// 스페이스바, 탭(\t), 엔터(\n)가 대환장 파티를 벌이는 문자열
String text = "사과 \t 바나나 \n\n 포도";
String[] arr = text.split("\\s+");

• \s (소문자 s): 스페이스바, 탭, 엔터 등 '눈에 보이지 않는 모든 종류의 공백(Whitespace)'을 의미하는 정규표현식 특수기호입니다. (자바에서는 역슬래시를 표현하기 위해 \\s로 두 번 적어줍니다.)
• + (더하기): 역시 1번 이상 연속됨을 의미합니다.

즉, split("\\s+")는 "스페이스바든, 탭이든, 줄바꿈이든 섞여서 몇 칸이 있든 전부 다 하나의 공백으로 취급해서 잘라버려라!"라는 무적의 코드가 됩니다.

최종 요약 (이것만 기억하세요!)

• split(" "): 띄어쓰기가 무조건 딱 1칸씩만 있을 때 쓴다.
• trim().split("[ ]+"): 스페이스바 띄어쓰기가 여러 칸으로 불규칙할 때 쓴다.
• trim().split("\\s+"): 스페이스바, 탭, 엔터 등 모든 종류의 공백이 섞여 있을 때 쓰는 가장 완벽한 마법의 1줄 코드!

코딩 테스트에서 문자열을 특정 기호(구분자)로 잘라 배열로 만들어야 하는 문제는 단골로 출제됩니다. 이때 많은 자바 입문자들이 습관적으로 StringTokenizer를 사용했다가 '오답' 판정을 받곤 합니다. 예를 들어, "oxooxoxxox"라는 문자열을 "x"를 기준으로 잘라서 각 조각의 길이를 구해야 한다고 가정해 봅시다. (원하는 정답 배열: [1, 2, 1, 0, 1, 0]) 분명 완벽하게 코드를 짠 것 같은데 왜 틀렸을까요? 자바가 문자열을 자르는 3가지 방식의 차이를 정확히 알아야 합니다.

1. StringTokenizer의 배신 (빈 공간 무시)

StringTokenizer는 애초에 문자열에서 '의미 있는 토큰(조각)'만 뽑아내기 위해 만들어진 아주 오래된 클래스입니다. • 동작 방식: 구분자("x")가 연속으로 나오거나 맨 앞/뒤에 있으면, 그 사이의 빈 공간을 완전히 무시(스킵)해 버립니다. • 결과: "oxooxoxxox" ➔ ["o", "oo", "o", "o"] (길이: 4) • 문제점: 우리가 원했던 '연속된 x 사이의 길이가 0인 빈 문자열'을 아예 배열에 담아주지 않습니다.

2. split("x")의 반쪽짜리 진실 (후행 빈 문자열 제거)

"그럼 split을 쓰면 되잖아?" 하고 split("x")를 사용하면 함정을 절반만 피한 것입니다. • 동작 방식: 중간에 있는 빈 문자열은 배열에 잘 담아줍니다. 하지만, 맨 마지막에 남는 빈 문자열들은 싹 다 버려버립니다. • 결과: "oxooxoxxox" ➔ ["o", "oo", "o", "", "o"] (길이: 5) • 문제점: 문자열 맨 끝에 "x"로 끝나면서 생기는 마지막 빈 공간을 잘라내 버립니다. (정답 길이가 6이어야 하는데 5가 나옴)

3. 완벽한 해결책: split("x", -1) (리미트 해제)

이 모든 문제를 해결하고 빈 공간을 하나도 빠짐없이 배열에 담으려면, split 메서드의 두 번째 파라미터인 limit(제한) 값을 조작해야 합니다. • 동작 방식: split(구분자, limit)에서 limit 자리에 음수(-1)를 넣으면, 자바에게 "배열의 크기 제한을 없애고, 맨 끝에 남는 빈 문자열까지 모조리 다 배열에 담아라!"라는 강력한 명령을 내리게 됩니다. • 결과: "oxooxoxxox" ➔ ["o", "oo", "o", "", "o", ""] (길이: 6) • 결론: 빈 문자열까지 정확하게 카운트해야 하는 코딩 테스트 문제에서는 무조건 split("구분자", -1)을 사용해야 완벽한 정답을 받을 수 있습니다.

(대상 문자열: "A,,B,,," / 구분자: ",")

그런데 다른 사람의 코드를 보다 보면 split(",", 3) 이나 split(",", -1) 처럼 뒤에 정체모를 숫자가 붙어있는 것을 종종 보게 됩니다.

이 두 번째 파라미터의 정체는 바로 limit(제한)입니다. 이 숫자가 양수일 때, 0일 때, 음수일 때 완전히 다른 3가지 마법을 부리는데요. 오늘 이 3가지 차이점을 완벽하게 정리해 드리겠습니다.

테스트를 위해 끝에 쉼표가 2개 더 붙어있는 아래 문자열을 예시로 들어보겠습니다. String text = "사과,배,포도,귤,수박,,";

1. 양수 (예: 3) ➔ "최대 N조각까지만 내라!"

양수는 "결과 배열의 방을 최대 몇 개까지만 만들 것인가?"를 뜻합니다.

String text = "사과,배,포도,귤,수박,,";
String[] arr = text.split(",", 3);

System.out.println(Arrays.toString(arr));
// 결과: ["사과", "배", "포도,귤,수박,,"]

💡 자바의 속마음:*"아, 최대 3조각까지만 내라고? 알겠어. 첫 번째 쉼표 자르고, 두 번째 쉼표 자르고... 앗! 벌써 방이 2개 찼네? 그럼 나머지는 더 이상 자르지 말고 마지막 3번째 방에 몽땅 때려 넣어!*"

• 언제 쓸까? (실무 꿀팁): 로그(Log) 파일이나 긴 문장을 처리할 때 아주 유용합니다. 앞의 몇 개 정보(날짜, 이름 등)만 떼어내고, 뒤에 있는 긴 내용은 자르지 않고 원본 그대로 보존하고 싶을 때 사용합니다.

2. 숫자 0 (기본값) ➔ "다 자르되, 뒤에 남는 쓰레기(빈 칸)는 버려라!"

사실 우리가 평소에 쓰는 split(",")은 자바 내부적으로 split(",", 0)과 완벽하게 똑같이 동작합니다. limit을 아예 적지 않으면 자바가 알아서 0을 넣어서 계산하기 때문입니다.

String text = "사과,배,포도,귤,수박,,";
String[] arr = text.split(",", 0); // text.split(",")과 완벽히 동일

System.out.println(Arrays.toString(arr));
// 결과: ["사과", "배", "포도", "귤", "수박"] 

자바의 속마음:*"구분자가 보일 때마다 전부 다 자를게! 어? 그런데 맨 끝에 쉼표가 남아서 빈 문자열("")이 생기네? 의미 없는 빈 칸은 쓰레기니까 내가 알아서 버려줄게!*"

• 특징: 우리가 가장 익숙하게 아는 방식입니다. 최대한 다 자르지만, 맨 끝에 남는 후행 빈 문자열들은 배열에 포함시키지 않고 날려버립니다.

3. 음수 (예: -1) ➔ "제한 해제! 끝까지 다 자르고 빈 칸도 전부 살려라!"

음수(보통 -1을 씁니다)가 들어가면 자바는 "limit 무한대(제한 없음)" 모드로 돌입합니다.

String text = "사과,배,포도,귤,수박,,";
String[] arr = text.split(",", -1);

System.out.println(Arrays.toString(arr));
// 결과: ["사과", "배", "포도", "귤", "수박", "", ""] 

자바의 속마음:*"제한 해제! 중간이든 맨 끝이든 쉼표가 보이면 무조건 다 자른다. 그 결과로 생기는 빈 문자열("")조차도 하나의 소중한 데이터로 인정해서 배열에 모조리 담아줄게!*"

• 언제 쓸까? (코딩테스트 필수): 빈 문자열도 꼬박꼬박 개수에 포함시켜야 하는 알고리즘 문제나, 엑셀/CSV 데이터처럼 빈칸 데이터가 누락되면 안 되는 상황에서 무조건 사용해야 하는 정석 코드입니다.

매번 if-else문과 for문을 쓰다 보면 코드가 길어지고 지저분해지기 마련이죠. 오늘은 이 두 가지 노가다(?) 작업을 단 한 줄로 깔끔하게 끝내주는 자바의 핵심 도우미 메서드 2가지를 소개합니다.

1. Integer.compare(A, B) : "비교 결과를 숫자로 딱 정해줄게!"

코딩 테스트를 풀다 보면 "A가 B보다 크면 1, 같으면 0, 작으면 -1을 반환하라"는 요구사항을 정말 자주 봅니다. 보통은 아래와 같이 코드를 작성하게 됩니다.

기존의 방식 (길고 장황함)

int a = 10;
int b = 5;

if (a > b) {
    return 1;
} else if (a < b) {
    return -1;
} else {
    return 0;
}

세련된 방식 (단 한 줄!)

return Integer.compare(a, b);

이 코드는 앞선 7줄짜리 if-else문과 완벽하게 똑같이 동작합니다.

왜 이 메서드를 알아야 할까요? 자바에서 1, 0, -1을 반환하는 것은 값을 비교할 때 사용하는 가장 표준적인 약속입니다. 자바를 만든 사람들은 이 규칙을 매번 작성하는 것이 번거로울 것을 알고, 아예 Integer 클래스 안에 compare라는 함수로 만들어 두었습니다. 나중에 객체를 정렬(Sorting)할 때 쓰이는 Comparator나 Comparable을 다룰 때도 이 원리가 똑같이 적용되므로 무조건 외워두시는 것이 좋습니다!

2. IntStream.of(배열).sum() : "for문 안 돌려도 내가 다 더해줄게!"

배열 안에 있는 숫자들을 전부 더할 때, 우리는 무의식적으로 sum이라는 변수를 0으로 만들고 for문을 돌립니다.

기존의 방식 (전통적인 for문)

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

for (int i = 0; i < arr.length; i++) {
    sum += arr[i];
}
return sum;

세련된 방식 (Stream API 활용) 자바 8부터 도입된 스트림(Stream)을 사용하면 이 과정을 한 줄로 우아하게 끝낼 수 있습니다.

int[] arr = {1, 2, 3, 4, 5};
return IntStream.of(arr).sum();

어떻게 작동하는 걸까요? 이 코드는 공장의 '컨베이어 벨트'를 상상하면 쉽습니다.

1. IntStream.of(arr): 배열(arr)에 있는 숫자들을 작업하기 편하도록 컨베이어 벨트 위로 쫙 일렬로 올려놓습니다. (참고로 Arrays.stream(arr)이라고 써도 완벽하게 똑같이 작동합니다!)
2. .sum(): 벨트 맨 끝에 서서, 지나가는 숫자들을 남김없이 싹쓸이해서 더한 뒤 최종 결괏값을 툭 뱉어냅니다.

sum() 외에도 가장 큰 값을 찾는 .max(), 평균을 구하는 .average() 등 다양한 통계 기능을 기본으로 제공하므로 배열을 다룰 때 아주 강력한 무기가 됩니다.

오늘은 char[]을 String으로 변환하는 정석적인 방법과, 왜 다른 방식들이 실패하는지 그 이유를 명확히 정리해 보겠습니다.

1. new String(arr) 사용하기

자바에서 가장 정석적이고 빠르게 문자 배열을 문자열로 변환하는 방법은 String 클래스의 생성자를 사용하는 것입니다.

String myString = "apple";

// 1. 문자열을 낱개 글자 배열(char[])로 분리
char[] arr = myString.toCharArray(); 

// (배열의 내용 수정 작업 진행...)
arr[0] = 'A';

// 2. 수정된 문자 배열을 다시 하나의 문자열로 병합
String result = new String(arr); 

System.out.println(result); // 출력: Apple

동작 원리: 자바에서 String 객체는 내부적으로 문자들의 배열(char[]) 형태로 데이터를 관리합니다. 따라서 new String(arr)처럼 생성자에 문자 배열을 넘겨주면, 자바는 해당 배열의 요소들을 순서대로 읽어 완벽한 형태의 새로운 String 객체로 재조립하여 반환해 줍니다.

2. 왜 기존 방식에서는 '주소값'이나 '이상한 형태'가 나왔을까?

문자열로 바꾸기 위해 무작정 .toString()을 호출하거나 Arrays.toString()을 사용했다면 다음과 같은 실패를 겪게 됩니다. 이는 두 메서드의 본래 목적이 다르기 때문입니다.

케이스 A: arr.toString()을 쓴 경우 (메모리 주소값 출력)

char[] arr = {'a', 'p', 'p', 'l', 'e'};
System.out.println(arr.toString()); 

// 실제 출력: [C@15db9742 (해시코드)

배열 객체에 직접 .toString()을 호출하면 배열 내부의 글자들이 합쳐지는 것이 아닙니다. 자바에서 배열은 객체(Object)이므로, 최상위 클래스인 Object의 기본 toString()이 동작하여 "이 객체가 위치한 메모리 주소(해시코드)"를 문자열로 반환하게 됩니다.

케이스 B: Arrays.toString(arr)을 쓴 경우 (디버깅용 출력)

char[] arr = {'a', 'p', 'p', 'l', 'e'};
System.out.println(Arrays.toString(arr)); 

// 실제 출력: [a, p, p, l, e]

Arrays.toString()은 배열 안의 데이터를 확인하기 위해 자바가 제공하는 배열 상태 확인용(디버깅용) 유틸리티입니다. 따라서 우리가 원하는 매끄러운 단어 형태("apple")가 아니라, 배열의 구조를 그대로 보여주는 대괄호([])와 쉼표(,)가 포함된 형태의 문자열을 만들어 버립니다. 알고리즘 문제의 정답(순수 문자열)으로는 사용할 수 없습니다.

보너스 꿀팁: 실수(소수) 입력받기

문자열이나 알고리즘 문제에서 콘솔 입력을 받을 때, 데이터 타입에 맞는 파싱(Parsing) 메서드를 사용하는 것도 매우 중요합니다.

정수를 받을 때는 Integer.parseInt()를 사용하지만, 소수점이 포함된 실수 값(예: 3.14)을 입력받아야 할 때는 반드시 Double 클래스를 사용해야 에러(NumberFormatException)가 발생하지 않습니다.

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

// 정수를 받을 때
int num1 = Integer.parseInt(br.readLine());

// 실수를 받을 때 (double 타입)
double num2 = Double.parseDouble(br.readLine());

이 두 가지 개념을 헷갈리는 이유는 '데이터를 다루는 목적'이 완전히 다르다는 점을 간과하기 때문입니다. 결론부터 말씀드리면, 배열은 데이터의 '저장소'이며 스트림은 데이터의 '가공 파이프라인'입니다. 오늘은 이 두 가지의 명확한 차이점과 상호보완적인 관계를 자바의 동작 원리를 통해 기술적으로 정리해 보겠습니다.

1. 배열과 컬렉션 (데이터의 보관)

배열(Array)이나 자바 컬렉션 프레임워크(List, Set, Map)의 근본적인 목적은 메모리 상에 데이터를 안전하게 구조화하여 '저장'하고 '유지'하는 것입니다.

• 물리적인 공간 할당: 배열은 생성될 때 메모리에 물리적인 연속된 공간을 차지합니다.
• 상태 유지: 데이터의 추가, 삭제, 수정 등 '상태(State)'를 관리하는 것이 주된 역할입니다.
• 데이터의 보존: 프로그램이 종료되거나 가비지 컬렉터(GC)에 의해 소멸하기 전까지 데이터는 그 자리에 계속 남아있습니다.

2. 스트림 (데이터의 연산과 가공)

반면 스트림(Stream)은 데이터를 물리적으로 저장하는 자료구조가 아닙니다. 배열이나 컬렉션에 저장된 데이터를 가져와서 개발자가 원하는 대로 조작(필터링, 매핑, 정렬 등)하기 위한 '연산의 흐름'을 제공하는 API입니다.

• 저장하지 않음: 스트림은 요소를 저장하지 않습니다. 단지 원본 데이터(배열)에서 요소를 하나씩 소비하며 연산을 수행할 뿐입니다.
• 원본의 불변성 (Immutability): 스트림은 연산 과정에서 원본 배열의 데이터를 절대 변경하지 않습니다. 가공된 새로운 결과물만 반환합니다.
• 일회용 (Consumable): 스트림은 한 번 연산(최종 연산)이 끝나면 닫히며 재사용할 수 없습니다. 필요하다면 원본 배열에서 새로운 스트림을 다시 열어야 합니다.

3. 배열과 스트림의 관계 (상호 협력)

배열과 스트림은 경쟁 관계나 대체제가 아닙니다. "배열(소스)을 기반으로 스트림(연산)을 생성하여 데이터를 가공한다"는 완벽한 협력 관계를 맺고 있습니다.

이를 가장 명확하게 보여주는 것이 반복 방식의 차이입니다.

외부 반복 (External Iteration) - 배열 중심

기존의 배열 처리 방식입니다. 개발자가 직접 for문이나 Iterator를 사용하여 배열의 요소를 하나씩 꺼내오고(Pull), 그 안에서 데이터를 지지고 볶는 로직을 모두 구현해야 합니다.

// 원본 배열(소스)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = new ArrayList<>();

// 외부 반복: 개발자가 직접 배열을 순회하며 제어함
for (Integer num : numbers) {
    if (num % 2 == 0) {
        evenNumbers.add(num);
    }
}

내부 반복 (Internal Iteration) - 스트림 중심

스트림을 사용한 방식입니다. 개발자는 데이터 가공 로직(조건식)만 제공하고, 반복과 처리는 스트림 내부에서 알아서 수행합니다(Push)

// 원본 배열(소스)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 내부 반복: 배열에서 스트림을 생성하여 데이터 가공을 위임함
List<Integer> evenNumbers = numbers.stream()
                                   .filter(num -> num % 2 == 0)
                                   .toList(); // (Java 16+)

결론

배열과 스트림을 혼동하지 않는 가장 좋은 방법은 역할을 완벽히 분리하는 것입니다. 데이터를 '담아두고 관리'해야 할 때는 배열을 고민하고, 담겨있는 데이터를 조건에 맞게 '뽑아내거나 변환'해야 할 때는 주저 없이 스트림 파이프라인을 구축하세요. 이 두 가지를 적절히 조화시킬 때 자바 프로그래밍의 효율성과 코드의 가독성은 극대화됩니다.

List<Integer> list = List.of(1, 2, 3);
int[] arr = list.stream().mapToInt(i -> i).toArray();

처음 이 문법을 접하면 *"이게 정확히 무슨 뜻이지?", *"i는 Integer에서 int로 바뀌는 건가?", *"i 대신 다른 변수나 식을 써도 되나?"* 와 같은 의문이 들 수 있습니다. 오늘은 자바 8부터 도입된 람다식(Lambda Expression)을 바탕으로 이 코드의 정확한 동작 원리와 활용법을 정리해 보겠습니다.

1. i -> i 의 정확한 의미와 오토 언박싱 (Auto-Unboxing)

i -> i는 자바의 람다식 문법으로, 입력값(Input) -> 반환값(Output)의 구조를 띱니다.

List<Integer>와 같은 컬렉션에서 생성된 스트림(Stream<Integer>)을 통과하는 데이터들은 기본형 int가 아닌 래퍼 클래스(Wrapper Class)인 Integer 객체입니다. .mapToInt() 메서드는 이 객체 스트림을 원시 타입 스트림인 IntStream으로 변환(매핑)하는 역할을 합니다.

• 왼쪽의 i (입력값): 스트림에서 전달되는 Integer 타입의 객체입니다.
• 오른쪽의 i (반환값): 매핑의 결과로 반환할 값입니다. .mapToInt()를 사용했기 때문에 자바 컴파일러는 최종 반환 타입이 기본형 int여야 함을 알고 있습니다.

따라서 자바 컴파일러는 들어온 Integer 객체를 그대로 반환할 때, 내부적으로 객체에서 원시 타입 값을 추출하는 오토 언박싱(Auto-Unboxing)을 수행하여 int 값으로 변환해 내보냅니다.

2. 변수명은 자유롭게 지정 가능

람다식에서 사용된 i는 특수한 키워드가 아니라 단순한 매개변수(Parameter) 이름일 뿐입니다. for (int i = 0; i < 10; i++)에서 사용하는 i와 동일한 역할입니다.

따라서 코드의 가독성을 높이기 위해 개발자가 원하는 이름으로 자유롭게 변경하여 사용할 수 있으며, 모두 완벽하게 동일하게 동작합니다.

// 아래 코드는 모두 100% 동일하게 작동합니다.
.mapToInt(i -> i)
.mapToInt(num -> num)
.mapToInt(x -> x)
.mapToInt(value -> value)

3. mapToInt의 실무 및 응용 활용법

단순히 들어온 값을 그대로 통과시키는 것 외에도, 람다식을 조작하여 스트림 요소의 값을 입맛대로 가공하거나 추출할 수 있습니다.

① 값에 연산 적용하기

스트림을 통과하는 데이터에 즉각적으로 수학적 연산을 적용하여 매핑할 수 있습니다. 예를 들어 모든 요소의 값을 2배로 만들고 싶다면 아래와 같이 작성합니다.

// 들어온 x를 2배(x * 2)로 연산하여 IntStream으로 반환
int[] arr = list.stream().mapToInt(x -> x * 2).toArray();

② 메서드 참조 (Method Reference) 사용

i -> i를 통한 오토 언박싱에 의존하는 대신, Integer 클래스가 가진 intValue() 메서드를 직접 호출하라고 명시할 수 있습니다. 이 방식은 자바의 메서드 참조(Method Reference) 문법으로, 실무에서 더 명확하고 정석적인 코딩 스타일로 권장됩니다.

// i -> i 와 동일하게 동작하며, 더 명시적인 표현 방식입니다.
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

③ 다른 타입의 데이터에서 int 값 추출하기

스트림의 원본 데이터가 Integer가 아닌 전혀 다른 객체(String 등)일 때도 유용하게 사용됩니다. 객체 내부의 특정 값을 추출하거나 변환하여 IntStream을 생성할 수 있습니다.

예시 A: 문자열 리스트를 정수 배열로 변환

List<String> strList = List.of("10", "20", "30");

// 문자열 객체(str)를 받아 파싱(Integer.parseInt) 후 int로 반환
int[] parsedArr = strList.stream().mapToInt(str -> Integer.parseInt(str)).toArray();
// 결과: [10, 20, 30]

예시 B: 문자열 객체에서 '길이' 데이터만 추출

List<String> words = List.of("apple", "banana", "kiwi");

// 문자열 객체(word)를 받아 길이(length)를 int로 반환
int[] lengths = words.stream().mapToInt(word -> word.length()).toArray();
// 결과: [5, 6, 4]

오늘은 이 두 가지 문법의 정확한 동작 원리를 자바의 내부 메커니즘을 통해 설명하겠습니다.

1. 배열 출력 시 Arrays.toString()을 사용하는 이유

배열을 생성하고 System.out.println()으로 직접 출력하면 배열의 요소가 아닌 식별할 수 없는 문자열이 출력됩니다.

String[] arr = {"apple", "banana", "cherry"};
System.out.println(arr); 

// 출력 결과: [Ljava.lang.String;@15db9742

동작 원리: 자바에서 배열은 원시 타입(Primitive type)이 아닌 객체(Object)로 취급됩니다. 따라서 System.out.println() 메서드에 배열 객체를 넘기면 내부적으로 최상위 클래스인 Object의 toString() 메서드가 호출됩니다. Object.toString()은 기본적으로 [객체의 타입 시그니처 + @ + 메모리 주소(해시코드)] 형태의 문자열을 반환하도록 구현되어 있습니다. 따라서 위와 같은 결과가 나오는 것입니다.

해결 방법: 배열 내부에 존재하는 실제 데이터 요소들을 확인하려면 java.util.Arrays 클래스의 Arrays.toString() 메서드를 사용해야 합니다.

System.out.println(Arrays.toString(arr)); 
// 출력 결과: [apple, banana, cherry]

Arrays.toString()은 내부적으로 for문을 돌며 배열의 각 요소(element)에 접근하여 하나의 조합된 문자열(String)로 반환해주기 때문에, 우리가 원하는 데이터를 직관적으로 확인할 수 있습니다.

2. ArrayList.toArray()에 new String[0]을 넘기는 이유

ArrayList를 일반 배열로 변환할 때, 단순히 toArray() 메서드만 호출하지 않고 특정 타입의 빈 배열(new String[0])을 매개변수로 전달하는 방식을 주로 사용합니다.

ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");

// ArrayList를 배열로 변환
String[] arr = list.toArray(new String[0]);

이 코드가 작성되는 이유는 크게 두 가지 기술적 배경을 갖습니다.

1) 제네릭(Generic)의 타입 소거(Type Erasure)

자바의 제네릭은 컴파일 타임에만 타입 안정성을 검사하고, 런타임(실행 시간)에는 타입 정보가 지워지는 '타입 소거' 특징을 가집니다. 즉, ArrayList<String>은 컴파일이 끝나면 내부적으로 데이터를 Object 타입으로 관리합니다. 따라서 매개변수 없이 list.toArray()를 호출하면 반환되는 배열의 타입은 String[]이 아닌 Object[]가 되어버립니다. 이를 해결하기 위해 new String[0]이라는 타입 지정용 인스턴스를 넘겨주어, 반환받을 배열의 타입이 String임을 명시하는 것입니다.

2) 왜 하필 크기가 0인 배열(new String[0])인가?

인자로 넘긴 배열의 크기가 리스트의 실제 데이터 크기보다 작을 경우, 자바의 toArray() 메서드는 내부적으로 다음과 같이 동작합니다.

1. 전달받은 배열의 크기가 부족하므로 해당 배열을 사용하지 않는다.
2. 전달받은 배열의 '타입'만 참조하여, 리스트의 size와 동일한 크기의 새로운 배열을 내부적으로 메모리에 할당한다.
3. 데이터를 새로운 배열에 복사하여 반환한다.

과거에는 메모리 할당 비용을 줄이기 위해 list.toArray(new String[list.size()])처럼 리스트의 크기를 직접 계산해서 넘기는 방식이 권장되었습니다. 하지만 최신 JVM(Java 6 이후)에서는 길이가 0인 배열을 전달하는 것이 오히려 성능상 더 유리하도록 최적화되었습니다. 사전에 크기를 명시하는 방식은 리플렉션(Reflection) 비용과 동기화 오버헤드가 발생할 수 있기 때문에, 빈 배열(new String[0])을 넘겨 JVM이 내부적으로 최적화된 방식으로 새 배열을 생성하도록 위임하는 것이 현재의 표준 컨벤션입니다.

Plus

• Arrays.toString(배열): 1차원 배열의 내용물을 깔끔하게 보여준다.
• Arrays.deepToString(배열): 2차원 배열뿐만 아니라, 3차원, 4차원 등 모든 다차원 배열의 내부 값을 보여준다.

2차원 배열이상에서 행의 길이를 알고 싶으면 arr[i].length;로 사용한다.

public static int[] solution(int[] num_list, int n) {
    ArrayList<Integer> list = new ArrayList<>();

    for(int i = 0; i < num_list.length; i += n) {
        list.add(num_list[i]);
    }

    // 컴파일 에러: ArrayList<Integer>를 int[]로 바로 반환할 수 없음
    return list; 
}

ArrayList의 toArray() 메서드를 사용하더라도 Integer[]나 Object[]로만 변환될 뿐, 원시 타입(Primitive Type)인 int[]로는 바로 변환되지 않습니다.

이때 자바 8부터 도입된 Stream API를 사용하면 이 형변환 과정을 단 한 줄의 코드로 우아하게 처리할 수 있습니다.

`return list.stream().mapToInt(i -> i).toArray();`

이 코드가 내부적으로 어떻게 동작하여 ArrayList<Integer>를 int[]로 변환하는지 3단계로 나누어 살펴보겠습니다.

Stream API 변환 파이프라인 분석

1. .stream() : 객체 스트림 생성

가장 먼저 컬렉션(ArrayList)을 스트림으로 변환합니다.

• list.stream()을 호출하면 ArrayList에 담긴 데이터들을 순차적으로 처리할 수 있는 Stream<Integer> 타입의 객체 스트림이 생성됩니다.
• 이 단계에서는 여전히 데이터가 래퍼 클래스(Wrapper Class)인 Integer 객체 형태로 존재합니다.

2. .mapToInt(i -> i) : IntStream 변환 및 오토 언박싱 (Auto-Unboxing)

스트림의 요소를 기본형 스트림으로 변환하는 핵심 단계입니다.

• mapToInt() 메서드는 기존의 Stream<Integer>를 원시 타입 스트림인 IntStream으로 매핑(Mapping)합니다.
• 매개변수로 전달된 람다식 i -> i는 들어온 Integer 객체를 그대로 반환하라는 의미입니다.
• 이때, 자바 컴파일러는 내부적으로 Integer 객체에서 기본형 int 값을 추출하는 오토 언박싱(Auto-Unboxing)을 수행합니다.
• (참고: 람다식 대신 메서드 참조인 Integer::intValue를 사용하면 언박싱 과정을 더 명시적으로 표현할 수 있습니다.)

3. .toArray() : 배열로 수집 (종단 연산)

변환된 스트림 데이터를 최종적으로 배열로 묶어냅니다.

• 스트림 파이프라인의 최종 연산(Terminal Operation)입니다.
• 언박싱되어 IntStream을 통과한 순수 int 값들을 모아, 새로운 int[] 배열을 메모리에 할당하고 값을 복사한 뒤 이를 반환합니다.

요약

list.stream().mapToInt(i -> i).toArray()는 단순한 마법이 아니라, 스트림 생성 ➔ 객체의 언박싱 매핑 ➔ 원시 타입 배열로의 수집이라는 명확한 자바의 동작 방식을 따르고 있습니다.

반복문을 직접 작성하여 배열로 옮겨 담는 것(for문 사용)보다 성능 오버헤드는 아주 미세하게 존재할 수 있으나, 가독성과 유지보수성이 압도적으로 뛰어나기 때문에 실무와 코딩 테스트에서 가장 널리 권장되는 방식입니다.

기존 방식 (charAt 사용)

String str = "hello";
for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);
    System.out.println(c);
}

물론 이 코드도 훌륭하게 작동하지만, 매번 length()를 부르고 i 값을 관리하며 charAt(i)를 쓰는 과정이 조금 번거롭고 코드가 길어집니다.

하지만 자바에는 이 과정을 아주 우아하게 단 한 줄로 끝내버리는 마법 같은 문법이 있습니다.

향상된 방식 (toCharArray 사용)

String str = "hello";
for (char c : str.toCharArray()) {
    System.out.println(c);
}

코드가 정말 깔끔해지지 않았나요? 오늘은 이 한 줄의 코드가 내부적으로 어떻게 작동하는지 두 단계로 쪼개서 아주 쉽게 파헤쳐 보겠습니다.

1단계: toCharArray()의 역할

자바에서 String (문자열)은 단순한 글자의 나열이 아니라, 꽁꽁 포장된 거대한 객체(상자)입니다. 그래서 "상자 안에 있는 글자를 하나씩 차례대로 꺼내줘!"라는 명령을 곧바로 내릴 수가 없습니다.

이때 toCharArray() 메서드를 사용하면, 자바가 문자열 객체의 포장을 뜯어서 안에 들어있던 낱개 글자들을 새로운 문자 배열(char[])로 만들어 줍니다.

• str = "hello"; (포장된 문자열 객체)
• str.toCharArray() 실행 ➔ ['h', 'e', 'l', 'l', 'o'] 라는 배열 탄생!

2단계: 향상된 for문 (for-each) 작동 원리

이제 코드는 이렇게 변한 것과 같습니다. for (char c : ['h', 'e', 'l', 'l', 'o'])

자바 5부터 도입된 이 문법은 "향상된 for문(Enhanced for loop)"이라고 부릅니다. 배열이나 리스트 같은 바구니 안의 내용물을 처음부터 끝까지 아주 편하게 꺼내줍니다.

작동 규칙: for ( 담을_변수 : 털어낼_바구니(배열) )

1. 자바가 오른쪽 배열에서 첫 번째 값인 'h'를 꺼냅니다.
2. 왼쪽의 char c 변수에 'h'를 쏙 집어넣고 블록({ }) 안의 코드를 실행합니다.
3. 코드가 끝나면 다시 올라와서 두 번째 값인 'e'를 꺼내 c에 넣고 실행합니다.
4. 배열에 더 이상 꺼낼 글자가 없을 때까지 알아서 반복한 뒤 종료합니다.

컴퓨터는 속으로 무슨 생각을 할까? (진실)

우리가 저렇게 짧고 예쁘게 코드를 쓰면, 자바 컴파일러(번역기)가 컴퓨터가 알아들을 수 있도록 코드를 몰래 옛날 방식으로 풀어버립니다. 즉, 향상된 for문은 개발자를 편하게 해주는 Syntactic Sugar입니다.

실제 자바가 내부적으로 실행하는 코드:

char[] tempArray = str.toCharArray(); // 1. 배열을 하나 새로 만든다.
for (int i = 0; i < tempArray.length; i++) { // 2. 길이를 계산해서 0부터 끝까지 돈다.
    char c = tempArray[i]; // 3. 인덱스 번호로 하나씩 꺼내서 변수에 담아준다.
    System.out.println(c);
}

장점과 단점 (언제 써야 할까?)

이 완벽해 보이는 코드에도 상황에 따라 장단점이 존재합니다.

장점

1. 가독성 극대화: i 같은 인덱스 변수를 쓰지 않아서 코드가 훨씬 깔끔하고 읽기 좋습니다.
2. 에러 원천 차단: 인덱스 계산 실수를 할 일이 없으므로 무서운 ArrayIndexOutOfBoundsException 에러를 만날 일이 없습니다.

단점 (주의할 점)

1. 현재 위치(i)를 모름: 반복문을 돌다가 "지금이 몇 번째 글자지?"를 알아야 하는 로직이라면 사용할 수 없습니다. (이때는 기존의 기본 for문을 써야 합니다.)
2. 미세한 메모리 사용: toCharArray()가 내부적으로 새로운 배열을 생성하기 때문에, 극한의 메모리 최적화가 필요한 환경에서는 주의해야 합니다. (하지만 일반적인 실무나 코딩 테스트에서는 무시해도 될 수준입니다!)

가장 먼저 떠오르는 방법은 if-else문이겠지만, 상황에 따라 가독성을 높이거나 실행 속도를 극한으로 끌어올리는 다양한 방법이 있습니다. 오늘은 문자열 제어문을 처리하는 4가지 단계를 소개합니다.

1. 기본 중의 기본: if-else문 활용

가장 직관적이고 기본적인 방법입니다. 문자열의 길이만큼 반복문을 돌면서 하나씩 조건을 검사합니다.

public int solution(int n, String control) {
    int count = control.length();
    for (int i = 0; i < count; i++) {
        if (control.charAt(i) == 'w') {
            n += 1;
        } else if (control.charAt(i) == 's') {
            n -= 1;
        } else if (control.charAt(i) == 'd') {
            n += 10;
        } else if (control.charAt(i) == 'a') {
            n -= 10;
        }
    }
    return n;
}

동작에는 전혀 문제가 없지만, 조건이 많아질수록 코드가 길어지고 else if를 계속 타야 하므로 미세한 성능 저하가 발생할 수 있습니다.

2. 성능과 가독성을 한 번에: 향상된 switch문

if-else문보다 미세하지만 더 효율적이고 가독성도 훨씬 좋은 것이 바로 switch문입니다. 특히 Java 14부터 지원하는 화살표(->) 문법을 사용하면 코드가 예술적으로 깔끔해집니다.

public int solution(int n, String control) {
    for (int i = 0; i < control.length(); i++) {
        switch (control.charAt(i)) {
            case 'w' -> n += 1;
            case 's' -> n -= 1;
            case 'd' -> n += 10;
            case 'a' -> n -= 10;
        }
    }
    return n;
}

왜 더 빠를까요? 자바에서 switch문은 컴파일될 때 내부적으로 '해당 위치로 바로 점프'하는 방식(tableswitch 또는 lookupswitch)으로 최적화됩니다. 따라서 위에서부터 아래로 조건을 하나씩 다 검사해야 하는 if-else문보다 조건이 많을수록 더 빠른 성능을 보여줍니다.

3. 실무/코테 추천 스타일: toCharArray() + 향상된 for문

인덱스 i를 써서 charAt(i)로 접근하는 대신, 문자열을 문자 배열(char[])로 바꿔서 향상된 for문을 쓰면 코드가 훨씬 읽기 편해집니다.

public int solution(int n, String control) {
    for (char c : control.toCharArray()) {
        switch (c) {
            case 'w' -> n += 1;
            case 's' -> n -= 1;
            case 'd' -> n += 10;
            case 'a' -> n -= 10;
        }
    }
    return n;
}

가장 권장하는 스타일입니다. 코딩 테스트에서 작성 속도도 빠르고, 다른 개발자가 읽기에도 가장 직관적입니다.

4. 극한의 성능 최적화: 배열 매핑 (조건문 없애기)

만약 control 문자열의 길이가 1억 개쯤 되어서 "0.001초라도 실행 속도를 더 줄이고 싶다!"면 어떻게 해야 할까요? 이럴 때는 아예 if나 switch 같은 조건문 자체를 없애버리는 방법을 쓸 수 있습니다. 문자가 내부적으로는 아스키코드(숫자)라는 점을 이용하는 것입니다.

public int solution(int n, String control) {
    // 알파벳 소문자 아스키코드의 최대값(z=122)을 덮을 수 있는 넉넉한 크기의 배열 생성
    int[] move = new int[128]; 

    // 각 문자에 해당하는 위치에 변화량을 미리 적어둡니다.
    move['w'] = 1;
    move['s'] = -1;
    move['d'] = 10;
    move['a'] = -10;

    // 조건문(분기) 없이 배열 인덱스로 접근해 그냥 값을 더해버립니다!
    for (int i = 0; i < control.length(); i++) {
        n += move[control.charAt(i)];
    }
    return n;
}

이게 왜 압도적으로 빠를까요? CPU는 코드 실행 중 if나 switch 같은 조건문을 만날 때마다 "다음엔 어느 쪽으로 갈까?" 하고 예측(분기 예측, Branch Prediction)을 하느라 시간을 씁니다. 하지만 이 방식은 그런 고민 없이 배열에서 값을 바로 꺼내 더하기만 하므로 압도적으로 빠른 속도를 자랑합니다. 알고리즘 고수들이 종종 쓰는 테크닉입니다.

1. StringTokenizer의 함정: countTokens()는 고정값이 아니다!

토큰의 개수만큼 배열을 만들고, 반복문을 돌려 값을 채워 넣는 아래 코드를 볼까요?

잘못된 방식

BufferedReader br = new BufferedReader(new InputStreamReader([System.in](http://system.in/)));
StringTokenizer st = new StringTokenizer(br.readLine().replace("\"", ""), ", ");
String[] arr = new String[st.countTokens()];
// 함정 발생 구간!
for(int i = 0; i < st.countTokens(); i++){
    arr[i] = st.nextToken();
}

언뜻 보면 문제없어 보이지만, 이 코드는 배열을 끝까지 채우지 못하고 중간에 멈춰버립니다.

이유는 st.nextToken()을 호출할 때마다 남아있는 토큰이 줄어들면서 st.countTokens()의 값도 계속 작아지기 때문입니다. (처음엔 3개여서 통과 ➔ 다음 바퀴엔 2개 ➔ 1개... 결국 반복문이 일찍 종료됩니다.)

올바른 방식

int count = st.countTokens(); // 변수에 미리 개수를 고정해둔다!
String[] arr = new String[count];

for(int i = 0; i < count; i++){
    arr[i] = st.nextToken();
}

반드시 count라는 변수에 초기 토큰 개수를 미리 저장해두고, 그 고정된 숫자를 기준으로 반복문을 돌려야 합니다.

2. String.join의 올바른 사용법

배열에 있는 문자열들을 하나로 합치고 싶을 때, 굳이 반복문을 돌릴 필요가 없습니다.

잘못된 방식 (반복문 사용)

String answer = "";
for(int i = 0; i < arr.length; i++){
    answer = String.join(arr[i]); // 이렇게 쓰면 안 됩니다!
}

올바른 방식 (한 줄로 끝내기)

return String.join("", arr);

String.join은 반복문 없이 배열 전체를 한 번에 합쳐주는 마법 같은 메서드입니다. 첫 번째 인자로 들어가는 ""는 구분자입니다. 빈 문자열("")을 주면 글자 사이에 아무것도 넣지 않고("abc") 다닥다닥 예쁘게 붙여줍니다.

3. 홑따옴표('') vs 쌍따옴표("") 완벽 구분

파이썬이나 자바스크립트와 달리, 자바는 따옴표의 종류에 아주 엄격합니다.

왜 charAt(3) == "w"는 컴파일 에러가 날까?

string.charAt(3)은 문자열에서 3번 인덱스에 있는 딱 한 글자(char)만 쏙 뽑아옵니다.

• 왼쪽: string.charAt(3) ➔ char 타입

• 오른쪽: "w" ➔ String 타입

  자바 입장에서는 "가벼운 기본형 문자(char)와 무거운 객체(String)는 태생부터 달라서 비교할 수 없어!" 라며 에러를 냅니다.

올바른 비교 방법

1. 같은 char 타입으로 비교하기 (추천)

if (string.charAt(3) == 'w') { // 둘 다 char 타입이므로 == 사용 가능
    // ...
}

2. 굳이 쌍따옴표(String)와 비교하고 싶다면?

// char를 String으로 바꾼 뒤, .equals()로 비교해야 합니다.
String 뽑은글자 = String.valueOf(string.charAt(3));

if (뽑은글자.equals("w")) {
    System.out.println("w가 맞습니다!");
}

1. 문자열 자르기의 기본: substring()

문자열의 특정 부분만 잘라내고 싶을 때는 substring()을 사용합니다.

my_string.substring(0, n)

위와 같이 작성하면 인덱스 0번째부터 n-1번째까지의 문자열을 출력해 줍니다. (시작 인덱스는 포함하고, 끝 인덱스는 포함하지 않는다는 점을 기억하세요!)

2. String 선언과 초기화: 빈 문자열("") vs null

문자열 변수를 선언할 때 String st;라고만 선언하면 변수에 아무런 값도 들어가지 않아 사용할 때 에러가 발생할 수 있습니다. 따라서 String st = ""; 처럼 빈 문자열로 초기화해 주는 것이 좋습니다.

주의! 초기화할 때 null의 함정 만약 String st = null;이라고 초기화한 뒤 st += 1;을 하면 어떻게 될까요? 결과는 "1"이 아니라 "null1"이 되어버립니다. null이라는 글자 뒤에 숫자가 그대로 붙어버리기 때문입니다. 반드시 쌍따옴표("")로 초기화하는 습관을 들입시다!

참고로 문자열에 숫자를 더할 때, st += String.valueOf(num); 처럼 명시적으로 바꿔줘도 되지만, st += num; 이라고만 써줘도 자바가 알아서 숫자를 문자로 바꿔서 더해줍니다.

3. 문자열 더하기 연산: String += vs StringBuilder

배열에 있는 홀수와 짝수를 각각 이어 붙이는 상황을 가정해 봅시다.

비효율적인 방식 (String += 사용)

위 코드처럼 odd += ... 형태로 문자열을 더해주는 방식은 매우 비효율적입니다. 자바에서 String은 값이 변하지 않는(불변) 객체이기 때문에, += 연산을 할 때마다 기존 메모리를 버리고 새로운 메모리 공간을 계속해서 생성하게 됩니다. 데이터가 많아질수록 성능이 크게 떨어집니다.

효율적인 방식 (StringBuilder 사용)

public static int solution(int[] num_list) {
    StringBuilder odd = new StringBuilder();
    StringBuilder even = new StringBuilder();

    for (int num : num_list) {
        if (num % 2 == 0) {
            even.append(num);
        } else {
            odd.append(num);
        }
    }
    return Integer.parseInt(odd.toString()) + Integer.parseInt(even.toString());
}

StringBuilder를 사용하면 기존 메모리 공간을 재활용하여 문자열을 이어 붙이기(append) 때문에 메모리 낭비 없이 훨씬 빠르고 효율적으로 작업할 수 있습니다. 반복문 안에서 문자열을 더할 일이 있다면 무조건 StringBuilder를 사용하는 것이 좋습니다!

먼저 int 배열을 받은 것을 n번째부터 배열 끝까지 출력하기 위해 for문을 사용해서 출력해줬다. 하지만 이 방법보다 더 효율적인 방법이 있다.

바로 System.arraycopy (성능 최적화), Arrays.copyOfRange (가독성 최적화) 이다.

1. for문 대신 System.arraycopy

public static int[] solution(int[] num_list, int n) {
int length = num_list.length - n + 1;
int[] arr = new int[length];
// 원본배열, 시작위치, 복사본배열, 복사본시작위치, 복사할길이
System.arraycopy(num_list, n - 1, arr, 0, length);
return arr;
}

arr을 설정해주고 arraycopy를 사용해서 기존의 num_list에서 복사해주면 된다.

원본배열, 시작위치, 복사본배열, 복사본시작위치, 복사할길이 순서대로 입력해주면 된다.

2. Arrays.copyOfRange (가독성 최적화)

public static int[] solution(int[] num_list, int n) {
// n-1 인덱스부터 num_list.length 인덱스 "전"까지 복사
return Arrays.copyOfRange(num_list, n - 1, num_list.length);
}

바로 활용할 수 있는 방법으로 n-1 인덱스부터 num_list.length 인덱스 "전"까지 복사한다.

마지막으로 배열 vs ArrayList을 구분해보자

num_list.length - n + 1이라는 명확한 크기 계산식이 나올 때는 배열(int[])을 쓰는 것이 메모리 효율과 속도 측면에서 더 좋다고 한다

ArrayList는 입력되는 데이터가 몇 개일지 도저히 모를 때, 중간에 데이터를 넣거나 빼야 할 때(배열은 삭제가 힘들지만, ArrayList는 메서드 하나로 해결) 사용하는게 좋다.

→ 에러 발생 : 크기가 0이라 값을 넣을 수 없어 에러

배열 생성 시: 반드시 new int[크기] 처럼 숫자를 넣어줘야 값을 담을 공간이 생긴다.

반복문 주의: st.countTokens()처럼 값이 변하는 메서드는 변수에 담아서 사용

출력: int[] 객체를 그냥 출력하면 주소값이 나오니, 출력할 때 Arrays.toString()사용

핵심으로 들어가서 int 배열을 받기 위해서는

                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int count =st.countTokens();
        int[] arr = new int[count];
        for(int i=0; i<count; i++){
            arr[i]=Integer.parseInt(st.nextToken());
        }

위와 같이 StringTokenizer을 사용해서 countTokens로 배열의 공간 확보, string을 받은 뒤 nextToken으로 배열에 넣어주면 된다.

고정된 크기가 없을 때: ArrayList 활용

StringTokenizer st = new StringTokenizer(br.readLine());
ArrayList<Integer> list = new ArrayList<>();
while (st.hasMoreTokens()) {
list.add(Integer.parseInt(st.nextToken()));

입력되는 숫자가 몇 개인지 미리 알 수 없을 때(배열 크기를 정할 수 없을 때) 사용한다

public static int[] solution(int[] num_list, int n) {
        int[] answer = new int[n];
        for(int i=0; i<n; i++){
            answer[i]=num_list[i];
        }
        return answer;
    }

여기서 return answer을 해주면 answer의 주소 반환해준다.

Arrays.toString(result)

그런데 이때, result가 배열 전체를 잘 받았더라도, 그냥 System.out.println(result);라고 하면 우리가 원하는 [1, 2, 3] 같은 모양이 나오지 않는다.

• 그냥 출력 시: [I@6d06d69c 같은 이상한 메모리 주소값이 나온다.
• 내용물을 보려면: Arrays.toString(result)를 써야 배열의 값이 다 출력된다.

int ba = Integer.parseInt("" + b + a); 처럼 빈 문자열을 앞에 두면 자바가 알아서 뒤의 숫자들을 문자열로 취급해 붙여준다. (이때 a,b는 int형이고 “”를 통해 문자열로 취급한다.)

public static int solution(int a, int b) {
        int ab = Integer.parseInt("" + a + b);
        int ba = Integer.parseInt("" + b + a);
        return (ab >= ba) ? ab : ba;
    }

Math.max(): 삼항 연산자 (a > b) ? a : b 대신 자바 표준 라이브러리인 Math.max(ab, ba)를 쓰면 코드가 훨씬 더 직관적이게 된다.

public int solution(int a, int b) {
        String strA = String.valueOf(a);
        String strB = String.valueOf(b);
        String strSum1 = strA + strB;
        String strSum2 = strB + strA;
        return Math.max(Integer.valueOf(strSum1), Integer.valueOf(strSum2));
    }

public int solution(int a, int b) {
        int ab = Integer.parseInt(Integer.toString(a) + Integer.toString(b));
        int ba = Integer.parseInt(Integer.toString(b) + Integer.toString(a));
        return ab >= ba ? ab : ba;
    }

String.valueOf(a) vs Integer.toString(a)

둘 다 숫자를 문자열로 바꾸는 역할이지만 내부적인 작동 방식에 약간의 차이 존재

• String.valueOf(a): 내부적으로 Integer.toString(a)을 호출합니다. 즉, Integer.toString을 한 번 더 감싸놓은 형태로 만약 입력값이 null이라면 "null"이라는 문자열을 반환하는 안전장치가 존재
• Integer.toString(a): 정수(int)를 직접 문자열로 변환하는 가장 직접적인 메서드

숫자를 문자로: "" + a 또는 String.valueOf(a)

Integer.valueOf() vs Integer.parseInt()

이 둘도 비슷하지만 반환하는 타입이 다릅니다.

• Integer.parseInt(s): 결과값으로 기본형(int)을 반환 (산술 연산에 최적화)
• Integer.valueOf(s): 결과값으로 객체형(Integer)을 반환합니다.

그럼 왜 parseInt 대신 valueOf를 써도 돌아가나요? 자바에는 Auto-boxing/Unboxing이라는 기능이 있어서, 객체(Integer)를 숫자(int)가 필요한 곳에 넣으면 자바가 알아서 꺼내서 사용한다. 하지만 단순히 숫자 비교나 연산을 위해서라면 메모리 효율상 parseInt를 쓰는 것이 정석이다.

Integer. 이나 String.을 앞에 붙여야 하는 이유

자바는 모든 메서드가 특정 클래스 안에 소속되어 있어야 합니다. 이때 'Static 메서드(정적 메서드)'라는 개념이 등장합니다.

• 도구함 개념: Integer라는 클래스는 "정수와 관련된 유용한 도구들의 집합소"
• 우리가 망치가 필요할 때 공구함.꺼내기(망치) 하듯이, 문자열을 숫자로 바꾸는 도구가 Integer라는 공구함 안에 들어있기 때문에 Integer.parseInt()라고 부르는 것입니다.
• 마찬가지로 문자열 관련 도구는 String 공구함에 들어있어 String.valueOf()라고 씁니다.

Integer vs int (대문자와 소문자의 차이)

1. int (기본형, Primitive Type): 단순히 숫자 값만 저장
   • int a = 10; 처럼 쓰며, 별도의 기능(메서드)이 없습니다. (a.parseInt() 이런 게 안됨.)
2. Integer (래퍼 클래스, Wrapper Class):
   • 기본형인 int를 객체로 감싸서 다양한 기능(메서드)을 제공
   • 그래서 "문자열을 숫자로 바꾸는 기능" 같은 복잡한 로직은 소문자 int가 아니라 대문자 Integer 클래스가 가지고 있는 것입니다.

최종 요약

• valueOf(a) 를 쓰면 Integer.toString(a)을 호출해 a의 값이 null(즉 아무값도 없으면) 이를 String.valueof(a)라 하면 “null”로 출력된다. 아래 표 참조!!

String.toLowerCase() : 모두 소문자로 변환

String.toUpperCase() : 모두 대문자로 변환

public static String solution(String myString) { return myString.toUpperCase(); // 대문자로 변환된 "새로운 문자열"을 바로 반환 }

public static String solution(String myString) { myString.toUpperCase(); // 새로운 대문자 문자열이 만들어졌지만, 아무데도 저장 안 함 (공중에 사라짐) return myString; // 바뀌지 않은 "원본" 소문자 문자열을 반환 }

→ 첫 번째는 대문자로 변환한 것을 바로 return해주고 두 번째는 대문자로 변환해주지만 이를 저장소에 저장하지 않아서 원래 문자가 나온다.

문자에 포함되어 있는지 찾기

contains(): 단순히 포함 여부만 궁금할 때 → boolean 형태

my_string.contains(target)

indexOf(): 포함 여부는 물론, 어느 위치에 있는지 알아야 할 때 → int 형태로 포함안되어있으면 -1 반환

my_string.indexOf(target)

for(int i=0; i<=n-m; i++){
            boolean match = true;
            for(int j=0; j<m; j++){
                if(my_string.charAt(i+j)!=target.charAt(j)){
                    match=false;
                    break;
                }
            }
            if(match){
                return 1;
            }
        }

이중 for문에서 안의 for문에서 break를 하면 가장 가까운 반복문으로 나오고

완전히 프로그램이나 함수를 끝내고 싶다면 break 대신 return을 사용

boolean 사용법

"모든 조건이 만족했는가?"를 확인할 때는 boolean isMatch = true;로 시작해서, 하나라도 틀리면 false로 바꾸는 방식이 가장 안전하다! 요구하는 것에 따라서 true, false 구분 잘하기

• new StringTokenizer(문자열, ", ")는 문자열 안에서 쉼표를 만나도 자르고, 공백을 만나도 자른다.
• StringTokenizer는 기본적으로 빈 문자열(비어있는 토큰)은 무시하기 때문에, 결과적으로 숫자들만 깔끔하게 가져오게 됩니다

입력값이 16,6, 5 12 (쉼표만 있는 경우, 쉼표+공백, 공백만 있는 경우 섞임)일 때:

만약 "쉼표+공백"이 꼭 붙어있는 경우에만 자르고 싶다면 split 사용

String[] parts = br.readLine().split(", ");

my_string.charAt(index_list[i]) : Java에서 String은 배열이 아니므로 반드시 .charAt() 메소드 사용

String[] 배열이 아니라 하나의 String이어야 합니다. 여러 문자를 합칠 때는 StringBuilder 사용

• StringBuffer는 여러 사람이 동시에 하나의 일기를 쓰는 상황을 대비해 "누가 쓰고 있으면 나머지는 기다려!"라고 문을 잠그는 기능(동기화)이 들어있습니다. 이 과정에서 오버헤드(비용)가 발생해 속도가 느려집니다.
• StringBuilder는 혼자서 일기를 쓰는 상황이라 문을 잠글 필요가 없습니다. 그래서 거추장스러운 절차 없이 훨씬 *빠르게** 동작합니다.

자바에서는 어떤 기능을 사용하기 위해 new 키워드를 사용하여 메모리에 그 기능을 할당하는데, 이를 객체 생성이라고 한다.

[BufferedReader 방식]

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

1. System.in: 바이트 단위로 입력을 받는 기본 객체
2. new InputStreamReader(...): 바이트를 문자(char)로 바꿔주는 다리 역할 객체
3. new BufferedReader(...): 문자를 버퍼에 담아 한 번에 읽게 해주는 최종 객체 (br)

[Scanner 방식]

Scanner sc = new Scanner(System.in);

1. System.in: 입력을 받는 기본 객체를 통째로 넘겨받습니다.
2. new Scanner(...): 이 입력값을 분석(Parsing)해서 숫자나 문자열로 요리해주는 객체 (sc)를 생성합니다.

br이나 sc 모두 System.in을 사용할 경우 프로그램 종료 시 GC가 정리해주긴 하지만, 자바의 정석은 close()를 명시해줘야 한다!

Scanner의 주요 메서드

next() : 공백(Space)이나 줄바꿈 전까지의 문자열을 읽음.

nextLine() : 한 줄 전체를 읽음 (엔터 키를 칠 때까지).

nextInt() : 정수를 읽음.

nextDouble() : 실수를 읽음.

예외 처리

• BufferedReader: readLine()을 쓸 때 반드시 throws IOException을 선언하거나 try-catch로 감싸야 합니다. (컴파일러가 강제함)
• Scanner: 예외 처리를 강제하지 않아 코드가 짧아 보이지만, 잘못된 타입 입력 시 InputMismatchException이 발생할 수 있습니다.

동기화 (Thread-safe)

• BufferedReader: 여러 스레드가 동시에 접근해도 안전합니다.
• Scanner: 멀티스레드 환경에서 안전하지 않습니다.