[JAVA] 스트림 문법 정리

자바 Stream 문법 정리

스트림 쓸 때마다 문법이 헷갈려서 매번 검색하게 된다.사실 스트림 문법 잘 몰랐는데 프로그래머스에서 다른 사람들 풀이 볼때마다스트림이 등장해서 나도 공부해야겠다고 생각했다. (뭔가 멋있음 스트림으로 푸는 사람들) 
 

1. 스트림

스트림은 리스트나 배열 같은 데이터를 하나씩 처리하는 도구다. 원래 for문으로 하던 걸 더 짧고 읽기 쉽게 쓸 수 있다.
먼저 for문과 비교해보자. "리스트에서 2보다 큰 수만 골라서 10배 하기"를 예전 방식으로 하면 이렇다.

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

List<Integer> result = new ArrayList<>();
for (int n : numbers) {
    if (n > 2) {                // 조건에 맞는 것만
        result.add(n * 10);     // 바꿔서 담기
    }
}
// result: [30, 40, 50]

 
같은 걸 스트림으로 쓰면 이렇다.

List<Integer> result = numbers.stream()
    .filter(n -> n > 2)   // 2보다 큰 것만 고르기
    .map(n -> n * 10)     // 각각 10배로 바꾸기
    .toList();            // 리스트로 받기
// result: [30, 40, 50]

 
filter(고르기), map(바꾸기), toList(받기)처럼 하고 싶은 걸 순서대로 적기만 하면 된다.
for문처럼 임시 리스트를 만들고 add 하는 과정이 사라진다.

 

 

2. 스트림의 3단계 구조

 
               
스트림은 항상 이 순서로 흘러간다.

생성  →  중간 연산  →  최종 연산
stream()   filter, map...    toList, forEach...

• 생성 : 데이터를 스트림으로 만든다.
• 중연산 : 데이터를 고르거나 바꾼다. 여러 개를 이어붙일 수 있다.
• 최종 연산 : 결과를 만들어낸다. 이게 없으면 아무 일도 안 일어난다.

이 세 단계만 기억하면 나머지는 메서드 이름만 갈아끼우면 된다. 

 

1. 생성

// 리스트에서
List<Integer> numbers = List.of(1, 2, 3);
numbers.stream();

// 배열에서
int[] arr = {1, 2, 3};
Arrays.stream(arr);

// 값을 직접 나열
Stream.of(1, 2, 3);

 

2. 중간 연산

 
데이터를 고르거나 바꾸는 단계이다.  자주 쓰는 함수들은 다음과 같다. 특히 filter랑 map을 자주 쓴다. 
 

filter(조건)	조건에 맞는 것만 남기기 (고르기)
map(변환)	각 요소를 다른 값으로 바꾸기
sorted()	정렬하기
distinct()	중복 제거
limit(n)	앞에서 n개만 남기기

 

filter  => 조건에 맞는 것만 고르기

numbers.stream()
    .filter(n -> n > 2);   // 2보다 큰 것만 → 3, 4, 5

map => 각 요소를 바꾸기

numbers.stream()
    .map(n -> n * 10);     // 각각 10배로 → 10, 20, 30

 
 
중간 연산은 이렇게 이어붙일 수 있다.

numbers.stream()
    .filter(n -> n > 2)    // 먼저 고르고 → 3, 4, 5
    .map(n -> n * 10);     // 그다음 바꾸기 → 30, 40, 50

 
 
 

3. 최종 연산

결과를 만들어내는 단계다.  이걸 붙여야 스트림이 실제로 실행된다. 

toList() / toArray()	결과를 리스트,배열로 받기
forEach(동작)	하나씩 꺼내서 실행 (예: 출력)
count()	개수 세기
sum()	합 구하기 (숫자 스트림 전용)

 

// 리스트로 받기
List<Integer> result = numbers.stream()
    .filter(n -> n > 2)
    .toList();                      // [3, 4, 5]

// 하나씩 출력하기
numbers.stream()
    .filter(n -> n > 2)
    .forEach(System.out::println);  // 3, 4, 5 를 한 줄씩

// 개수 세기
long count = numbers.stream()
    .filter(n -> n % 2 == 0)
    .count();                       // 짝수 개수 → 2

 
 
 
 

3. 전체 흐름 

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

List<Integer> result = numbers.stream()  // ① 생성
    .filter(n -> n > 2)                  // ② 고르기
    .map(n -> n * 10)                   // ② 바꾸기
    .toList();                           // ③ 받기

// result: [30, 40, 50]

 

1. 스트림은 생성 → 중간 연산 → 최종 연산 순서로 흘러간다.
2. 최종 연산(toList 등)을 안 붙이면 아무 일도 안 일어난다. 중간 연산만 써놓고 실행 안 돼서 당황하는 경우가 많다.
3.  filter(고르기) · map(바꾸기) · toList(받기) 이렇게 많이 사용된다. 

 
 
방금까지 얘기한 걸 기본 문법 위주로 한 번에 정리하면 다음과 같다. 

 

기본 뼈대

 

결과 = 데이터.stream()   // ① 생성
    .중간연산()          // ② 고르기/바꾸기 (여러 개 가능)
    .최종연산();         // ③ 결과 만들기

생성

List<Integer> list = List.of(1, 2, 3, 4, 5);
list.stream();                    // 리스트 → 스트림

int[] arr = {1, 2, 3};
Arrays.stream(arr);               // 배열 → 스트림

Stream.of(1, 2, 3);               // 값 직접 나열

 중간 연산 (고르고 바꾸기)

.filter(n -> n > 2)      // 조건에 맞는 것만 → 3, 4, 5
.map(n -> n * 10)        // 각각 바꾸기 → 10, 20, 30...
.sorted()                // 정렬
.distinct()              // 중복 제거
.limit(3)                // 앞에서 3개만

최종 연산 (결과 만들기)

.toList()                       // 리스트로 받기
.forEach(System.out::println)   // 하나씩 출력
.count()                        // 개수 세기
.sum()                          // 합 (숫자 스트림 전용)

 

---

 

코테에서 적용되는 예시

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// 예시 1) 2보다 큰 수만 10배 해서 리스트로
List<Integer> result = numbers.stream()
    .filter(n -> n > 2)
    .map(n -> n * 10)
    .toList();
// result: [30, 40, 50]

// 예시 2) 짝수 개수 세기
long count = numbers.stream()
    .filter(n -> n % 2 == 0)
    .count();
// count: 2

// 예시 3) 전체 합 구하기
int sum = numbers.stream()
    .mapToInt(Integer::intValue)   // 숫자 스트림으로 변환
    .sum();
// sum: 15