Java Stream(스트림) 완전 정리

배열/컬렉션을 “같은 방식”으로 처리하는 이유 + filter/map/sorted/forEach/sum/count/reduce까지

0) 스트림(Stream)이 뭐야?

슬라이드 요약을 아주 쉽게 풀면 이거야:

• 스트림(Stream) = “여러 자료(배열, 리스트 등)를 처리하는 기능(연산)을 모아둔 흐름(파이프라인)”
• 중요한 포인트:
  1. 배열이든 컬렉션이든 똑같은 방식으로 처리할 수 있음
  2. “자료 구조(배열/리스트)가 뭐냐”보다 “어떤 처리를 하고 싶냐”에 집중하게 해줌
  3. 반복문을 직접 돌리는 대신, 스트림이 내부적으로 요소를 하나씩 꺼내서 처리함(내부 반복)

✅ 비유

• 배열/리스트 = 재료가 담긴 박스
• 스트림 = 컨베이어 벨트(작업 라인)
• filter, map, sorted 같은 건 “작업 기계”
• 마지막에 forEach, sum, count, reduce 같은 “최종 버튼”을 눌러야 실제로 컨베이어가 움직임

---

1) 스트림을 쓰면 뭐가 좋아?

슬라이드 문장을 그대로 “의미”로 풀면:

✅ (1) 자료의 대상과 관계없이 동일한 연산 수행

• 배열이든 ArrayList든 똑같이:
  • .stream() 또는 Arrays.stream()로 스트림을 만들고
  • .filter().map().sorted().forEach() 같은 형태로 처리 가능

✅ (2) 한 번 생성하고 사용한 스트림은 재사용 불가 (소모됨)

• 스트림은 “컨베이어 벨트 한 번 돌리면 끝”이야.
• 한 번 forEach() 같은 최종 연산을 수행하면 그 스트림은 끝이라서 다시 못 써.

✅ (3) 스트림 연산은 기존 자료를 변경하지 않음

• 스트림은 원본 배열/리스트를 “직접” 바꾸는 게 아니라
  원본을 읽어서 새로운 결과를 만들거나 출력하는 방식이야.
  (단, 안에서 원본 객체 자체를 수정하면 그건 별개로 바뀔 수 있음)

✅ (4) 중간연산 + 최종연산 구조

• 중간연산: filter, map, sorted …
  → “가공” 단계(여러 개 연결 가능)
• 최종연산: forEach, sum, count, reduce …
  → “결과 만들기 / 출력” 단계(마지막에 1번만)

---

2) 반복문 vs 스트림: 가장 기본 예제

2-1) 반복문 버전

 

한 줄씩 해석

• int[] arr = {1,2,3,4,5};
  • 정수 배열 생성
• for (int i = 0; i < arr.length; i++)
  • 인덱스 i를 0부터 끝까지 증가
• System.out.println(arr[i]);
  • i번째 요소 출력

---

2-2) 스트림 버전

 

한 줄씩 해석(완전 찐으로)

• int[] arr = {1,2,3,4,5};
  • 배열 생성(동일)
• Arrays.stream(arr)
  • arr 배열을 IntStream(정수 스트림) 으로 바꿈
  • 즉, “배열 요소를 하나씩 흘려보낼 컨베이어 벨트” 생성
• .forEach(n -> System.out.println(n));
  • forEach는 최종연산
  • 스트림의 각 요소를 하나씩 꺼내서(내부적으로 반복)
  • n에 넣고 → System.out.println(n) 실행

✅ 여기서 람다 n -> System.out.println(n) 뜻

• n : 요소 하나
• -> : “이걸로 이렇게 실행할게”
• System.out.println(n) : 실행 내용
  즉, “요소 하나 들어오면 그걸 출력해라”

---

3) 스트림 파이프라인 구조: 생성 → 중간연산 → 최종연산

슬라이드 빨간 박스 그대로 구조는 이거야:

 

3-1) stream() = 스트림 생성(시작점)

• sList.stream()
  → 리스트를 스트림으로 “바꿔서” 요소들을 흘려보낼 준비

3-2) filter() = 중간연산(걸러내기)

• filter(s -> s.length() >= 5)
  • 조건을 넣고, 조건이 true인 것만 다음으로 통과
  • s -> s.length() >= 5는 “필터 조건식(판별식)”

✅ 비유

• filter = “검문소”
• 통과 조건 = length >= 5

3-3) forEach() = 최종연산(소비/출력)

• forEach(s -> System.out.println(s))
  • 통과된 요소를 하나씩 꺼내 출력
  • 실행하면 스트림이 소모(끝) 됨

---

4) map()은 뭐야? “형태 변환 / 원하는 값만 뽑기”

한 줄씩 해석

• customerList.stream()
  • 고객 객체들이 들어있는 리스트를 스트림으로
• .map(c -> c.getName())
  • 고객 객체 c를 받아서 → c.getName() 결과로 바꿈
  • 즉, Customer → String(이름) 으로 변환
• .forEach(s -> System.out.println(s))
  • 변환된 이름(String)을 하나씩 출력

✅ 비유

• map = “포장 뜯기”
• 고객 객체(박스)를 뜯어서 그 안에 있는 “이름”만 꺼내는 느낌

---

5) 최종연산: sum(), count() 그리고 “count가 long인 이유 + 캐스팅”

슬라이드 예제(정수 배열 합/개수):

한 줄씩 해석

• int[] arr = {1,2,3,4,5};
  • 배열 생성
• int sumVal = Arrays.stream(arr).sum();
  • Arrays.stream(arr) : IntStream 생성
  • .sum() : 최종연산
    → 요소들을 전부 더해서 int로 반환
• int count = (int) Arrays.stream(arr).count();
  • .count()는 최종연산
    → 요소 개수를 세서 반환
  • 근데 반환 타입이 long이야 (long count())
  • 그래서 int 변수에 넣으려면 (int)로 강제 형 변환(캐스팅) 필요

✅ 왜 count()는 long일까?
배열/컬렉션 크기가 엄청 클 수 있잖아.

• int 최대: 약 21억
• 데이터가 21억 개를 넘어갈 수도 있으니 안전하게 long으로 반환해.

✅ 실무적으로 더 안전한 코드

6) “스트림은 한 번 쓰면 재사용 불가”를 코드로 확인

슬라이드 느낌 그대로 예시를 정리하면:

 

한 줄씩 해석

• List<String> sList = new ArrayList<>();
  • 문자열 리스트 생성
• sList.add(...)
  • 요소 추가
• Stream<String> stream = sList.stream();
  • 리스트로부터 스트림 생성
  • (아직 실행은 안 됨)
• stream.forEach(s -> System.out.print(s + " "));
  • 최종연산 실행 → 요소 출력하면서 스트림 소모
• System.out.println();
  • 줄바꿈
• sList.stream().sorted().forEach(...)
  • 여기서 새 스트림을 다시 생성함 (sList.stream()을 다시 호출했지!)
  • 왜냐면 아까 stream은 이미 forEach로 소모돼서 재사용 불가니까

✅ 만약 이렇게 하면?

 

stream.sorted().forEach(...); // ❌ 에러 발생(이미 소비된 스트림)

---

7) sorted()는 뭐야?

• sorted()는 중간연산
• 요소들을 정렬한 “새로운 스트림”을 만들어 줌
• 문자열이면 기본 정렬(사전순/유니코드 순)

---

8) reduce() 완전 정복: “모든 값을 하나로 합치기(누적)”

슬라이드 정의:

 

8-1) reduce의 핵심 의미

• identity : 초기값(시작 값)
• accumulator : “두 값을 받아서 하나로 만드는 규칙”

✅ 비유

• reduce = “눈덩이 굴리기”
• identity = 처음 손에 쥔 작은 눈덩이(초기 크기)
• accumulator = “새 눈을 붙이는 방법(규칙)”

---

8-2) 정수 합 구하기 예시 (슬라이드)

 

한 줄씩 해석

• Arrays.stream(arr)
  • 배열을 IntStream으로
• .reduce(0, (a, b) -> a + b)
  • 초기값 0에서 시작
  • (a, b) -> a + b 규칙으로 계속 누적

✅ 내부에서 실제로 일어나는 느낌
arr이 [1,2,3,4,5]면:

• 시작: a=0
• a=0, b=1 → 1
• a=1, b=2 → 3
• a=3, b=3 → 6
• a=6, b=4 → 10
• a=10, b=5 → 15
  결과 15

---

8-3) reduce는 overload(형태)가 2가지가 자주 나옴

(A) identity 있는 reduce → 결과가 바로 T

 

• identity가 있으니까 “빈 경우”에도 결과가 무조건 나와서 String으로 바로 반환

(B) identity 없는 reduce → Optional<T>

 

• 요소가 하나도 없을 수 있으니 Optional로 감쌈
• 그래서 .get()을 쓰거나 orElse()를 써야 함

---

9) BinaryOperator 클래스로 reduce 규칙 만들기(슬라이드)

슬라이드 요지:

• BinaryOperator<T>는 “T 두 개 받아서 T 하나 반환”
• 우리가 클래스로 구현하면 apply()가 자동 호출됨

9-1) 가장 긴 문자열 고르는 규칙 클래스(슬라이드 스타일)

 

한 줄씩 해석

• class CompareString implements BinaryOperator<String>
  • 문자열 2개 비교해서 “하나”를 반환하는 규칙 클래스
• public String apply(String s1, String s2)
  • reduce가 내부적으로 계속 호출하는 메서드
• s1.getBytes().length
  • 문자열의 바이트 길이(한글은 보통 2~3바이트라 길게 나올 수 있음)
• 더 길면 s1 반환, 아니면 s2 반환
  → 결국 reduce 끝나면 “가장 길었던 문자열”이 남음

---

9-2) reduce에 적용(슬라이드)

 

한 줄씩 해석

• Arrays.stream(greetings)
  • 문자열 배열 스트림
• .reduce(new CompareString())
  • identity 없는 reduce → 결과가 Optional<String>
  • 내부적으로 apply(s1, s2)를 계속 호출해 “최종 1개”만 남김
• .get()
  • Optional에서 실제 값을 꺼냄
  • ⚠️ 단, 비어있으면 예외가 날 수 있음
  • 안전하게는 .orElse("") 추천
• System.out.println(str);
  • 최종 결과 출력

✅ 안전 버전

 

String str = Arrays.stream(greetings) .reduce(new CompareString()) .orElse("");

---

10) 실습 예제: 여행 고객(TravelCustomer) 스트림으로 처리하기

슬라이드 문제 요구:

1. 고객 명단 출력
2. 여행 총 비용 계산
3. 20세 이상 고객 이름을 정렬해서 출력

10-1) TravelCustomer 클래스(슬라이드 코드 해석)

 

포인트

• private 멤버변수 3개: 이름/나이/가격
• 생성자로 한 번에 세팅
• getter로 값 꺼내기
• toString()은 객체를 출력하면 어떤 문자열로 보일지 정함

---

10-2) TravelTest(슬라이드 코드 기반 + 변수명 오류 가능성 수정해서 “정상 버전”)

슬라이드에는 customerLee 만들어놓고 customerDong을 add하는 식으로
변수명이 섞여 보이는 부분이 있을 수 있어서, 실행 가능한 형태로 정리해줄게.

 

한 줄씩 “의미” 해석

• 고객 3명 객체 생성
  • 가격 100/100/50 (슬라이드 조건: 15세 이상 100만원, 미만 50만원과 매칭)
• List<TravelCustomer> customerList = new ArrayList<>();
  • 고객 리스트 준비
• customerList.add(...)
  • 리스트에 고객 넣기

(1) 고객 명단 출력

• customerList.stream() : 고객 스트림 생성
• map(c -> c.getName()) : 고객 → 이름(String)으로 변환
• forEach(...) : 이름 출력(최종연산)

(2) 총 비용 합

• mapToInt(c -> c.getPrice())
  • TravelCustomer → int(가격)으로 바꿈
  • IntStream이 됨
• sum() : 합계 계산(최종연산)

(3) 20세 이상만 + 이름만 + 정렬 + 출력

• filter(c -> c.getAge() >= 20) : 20세 이상만 통과
• map(c -> c.getName()) : 이름만 추출
• sorted() : 정렬(중간연산)
• forEach() : 출력(최종연산)

---

11) 실습 문제: Book 리스트에서

✅ 모든 책 가격의 합
✅ 20000원 이상인 책 이름을 정렬해서 출력
(슬라이드 “LibraryTest” 완성)

11-1) Book 클래스 (슬라이드 스타일 유지)

 

11-2) LibraryTest 완성 코드(스트림 사용)

 

ㅊ

한 줄씩 해석

(1) 합계

• bookList.stream() : 책 스트림 생성
• mapToInt(book -> book.getPrice())
  • Book → 가격(int)으로 변환 → IntStream
• sum() : 합계(최종연산)

(2) 20000원 이상 + 이름 + 정렬 + 출력

• filter(book -> book.getPrice() >= 20000) : 20000 이상만 남김
• map(book -> book.getName()) : 이름만 뽑기
• sorted() : 이름 정렬
• forEach(System.out::println)도 가능하지만(메서드 참조),
  여기서는 이해를 위해 람다로 유지:
  • forEach(name -> System.out.println(name))

---

12) 오늘의 핵심 요약(슬라이드 전체 내용 압축)

• 스트림은 배열/컬렉션을 같은 방식으로 처리하게 해주는 “데이터 처리 파이프라인”
• 스트림은
  • 원본을 직접 바꾸지 않고
  • 한 번 최종연산하면 소모되어 재사용 불가
• 연산은
  • 중간연산(filter/map/sorted...) 여러 개 가능
  • 최종연산(forEach/sum/count/reduce...) 마지막에 1번
• count()는 결과가 long → 필요하면 캐스팅하지만 보통 long으로 받는 게 안전
• reduce()는 “누적해서 하나로 합치는” 강력한 최종연산
  • 초기값(identity) 있으면 결과가 바로 T
  • 초기값 없으면 Optional 반환