Stream API란? (for-loop와 비교)

📌 1. Stream API란?

Stream API는 Java 8에서 도입된 기능으로, 컬렉션(List, Set 등)이나 배열의 데이터를 함수형 스타일로 처리할 수 있는 API.
간결하고 직관적인 코드를 작성할 수 있으며, 반복문보다 가독성이 좋고 병렬 처리도 지원한다.

 

📌 2. Stream의 특징

• 원본 데이터를 변경하지 않음 (불변성 유지)
• 중간 연산(Intermediate)과 최종 연산(Terminal)으로 나뉨
• 병렬 처리(parallelStream()) 가능

 

📌 3. Stream API 기본 동작 흐름

Stream API는 "데이터(Stream) 생성 → 중간 연산 (필터링, 변환 등) → 최종 연산 (리스트로 변환, 출력 등) " 의 구조로 작동한다.

 

📖 예제: 숫자 리스트에서 짝수만 골라 제곱 후 합산

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = numbers.stream()          // 1️⃣ Stream 생성
                 .filter(n -> n % 2 == 0) // 2️⃣ 중간 연산 (짝수 필터)
                 .map(n -> n * n)         // 3️⃣ 중간 연산 (제곱)
                 .reduce(0, Integer::sum); // 4️⃣ 최종 연산 (합계 계산)

System.out.println(sum); // 56 (2*2 + 4*4 + 6*6)

 

📌 4. Stream API 주요 메서드 정리

종류	메서드	설명
생성	stream()	컬렉션에서 Stream 생성
	Arrays.stream()	배열에서 Stream 생성
	Stream.of()	개별 요소로 Stream 생성
중간 연산 (Intermediate)	filter(Predicate)	조건에 맞는 요소만 필터링
	map(Function)	요소 변환 (ex. 소문자 → 대문자)
	sorted()	정렬
	distinct()	중복 제거
	limit(n)	n개의 요소만 가져오기
	skip(n)	처음 n개의 요소 건너뛰기
최종 연산 (Terminal)	collect(Collectors.toList())	리스트로 변환
	forEach()	각 요소를 반복하며 실행
	count()	요소 개수 반환
	reduce()	누적 연산 수행
	anyMatch(), allMatch(), noneMatch()	조건 검사

 

📌 5. Stream 함수 예제

✅5-1. filter() - 특정 조건의 요소만 선택

List<String> fruits = Arrays.asList("apple", "banana", "cherry", "avocado");
List<String> result = fruits.stream()
                            .filter(fruit -> fruit.startsWith("a")) // 'a'로 시작하는 것만
                            .collect(Collectors.toList());

System.out.println(result); // [apple, avocado]

 

✅5-2. map() - 요소 변환

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<Integer> squares = numbers.stream()
                               .map(n -> n * n) // 제곱
                               .collect(Collectors.toList());

System.out.println(squares); // [1, 4, 9, 16]

List<String> names = Arrays.asList("apple", "banana", "cherry");
List<String> upperCaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

System.out.println(upperCaseNames); // [APPLE, BANANA, CHERRY]

 

✅5-3. sorted() - 정렬

List<String> names = Arrays.asList("John", "Alice", "Bob");
List<String> sortedNames = names.stream()
                                .sorted()
                                .collect(Collectors.toList());

System.out.println(sortedNames); // [Alice, Bob, John]

 

 

✅5-4. reduce() - 누적 연산

단일 값을 반환한다.

// 1️⃣ 숫자
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, Integer::sum); // (초기값, 누적연산)

System.out.println(sum); // 15 (1+2+3+4+5)

// 2️⃣ 문자열
String combined = Stream.of("A", "B", "C")
                .reduce("", (a, b) -> a + b);
System.out.println(combined); // ABC

// 3️⃣ 객체
Person p1 = new Person("Alice", 20);
Person p2 = new Person("Bob", 25);

Person merged = Stream.of(p1, p2)
                .reduce(new Person(), (a, b) -> a.merge(b));
System.out.println(merged); // Person{name='AliceBob', age=45}

 

 

✅5-5. collect() - 값을 수집/변환

컬렉션이나 객체를 생성한다.

// 1️⃣ List 반환
List<String> list = Stream.of("A", "B", "C")
        .collect(Collectors.toList());
System.out.println(list); // [A, B, C]

// 2️⃣ Set 반환
Set<String> set = Stream.of("A", "B", "A")
        .collect(Collectors.toSet());
System.out.println(set); // [A, B]

// 3️⃣ Map 반환
Map<String, Integer> map = Stream.of("A", "B", "C")
        .collect(Collectors.toMap(s -> s, String::length));
System.out.println(map); // {A=1, B=1, C=1}

// 4️⃣ String 반환
String joined = Stream.of("A", "B", "C")
        .collect(Collectors.joining("-"));
System.out.println(joined); // A-B-C

// 5️⃣ 사용자 정의 타입 반환
StringBuilder sb = Stream.of("A", "B", "C")
        .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append);
System.out.println(sb); // ABC

 

📌 6. 자료형 별 Stream

Stream API는 Collection 계열(List, Set, Queue 등)에만 직접 사용할 수 있음.

• Collection: 요소 관리용 → Stream 활용 가능
• Map: 키 기반 조회용 → keySet(), values(), entrySet()로 Stream 처리
• 배열[]: 고정 크기, 메모리 연속 → 속도 빠름,  Arrays.stream() 사용으로 Stream 가능

 

📖 Map에 Stream 사용 예시 (정렬)

Map → Collection(Set) → Stream 순서로 변환

//📌 1. Java 8 Stream 활용 (가장 간단)
import java.util.*;
import java.util.stream.Collectors;

public class SortMapByValue {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("banana", 2);
        map.put("apple", 5);
        map.put("cherry", 1);

        // Integer 기준으로 정렬 후 key만 뽑기
        List<String> sortedKeys = map.entrySet().stream()
                .sorted(Map.Entry.comparingByValue()) // value 기준 정렬
                .map(Map.Entry::getKey)               // key만 추출
                .collect(Collectors.toList());

        System.out.println(sortedKeys); // [cherry, banana, apple]
    }
}

//📌 2. 역순(내림차순) 정렬하고 싶다면
List<String> sortedKeysDesc = map.entrySet().stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
        .map(Map.Entry::getKey)
        .collect(Collectors.toList());

System.out.println(sortedKeysDesc); // [apple, banana, cherry]

//📌 3. 람다식 사용
List<String> sortedKeys = map.entrySet().stream()
        .sorted((e1, e2) -> e1.getValue().compareTo(e2.getValue()))
        .map(Map.Entry::getKey)
        .collect(Collectors.toList());


//📌 4. Java 7 스타일 (스트림 없는 방식)
List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
list.sort((e1, e2) -> e1.getValue().compareTo(e2.getValue()));

List<String> sortedKeys = new ArrayList<>();
for (Map.Entry<String, Integer> entry : list) {
    sortedKeys.add(entry.getKey());
}

 

📌 7. parallelStream() - 병렬 처리

Stream은 기본적으로 순차 처리지만, 병렬 처리(parallelStream())를 사용하면 성능 향상 가능

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

System.out.println(sum); // 55 (1*1 + 2*2 + ... + 5*5)

 

✔ CPU 코어를 활용하여 여러 개의 스레드에서 병렬 실행
✔ 대량 데이터 처리에 유리하지만, 작은 데이터에서는 stream()이 더 적합

 

📌 8. stream 방식 vs for 루프 방식 비교

🔥 Stream API vs for 루프 요약

방식	장점	단점
Stream API (map())	✔️코드가 간결하고 가독성이 좋음  ✔️병렬 처리 가능 (parallelStream()) ✔️불변성 유지	❌ 디버깅이 어려움 ❌ 익숙하지 않은 개발자에게 어려울 수 있음
for 루프	✔️명확한 절차적 코드 ✔️디버깅이 쉬움 ✔️반복 중 개별적인 로직 추가 가능	❌ 코드가 길어지고 가독성이 낮음 ❌ 병렬 처리 지원 안 됨

 

✅8-1. Stream API 사용

List<ProductDetailDTO.ProductStockDto> stockDTOs = product.getStocks().stream()
    .map(stock -> new ProductStockDto(
        stock.getSize().getSizeName(),
        stock.getColor().getColorName(),
        stock.getStockQuantity()))
    .collect(Collectors.toList());

 

🔹 특징

• 한 줄로 간결하게 변환 가능 (map() 활용)
• 불변성 유지 → 원본 리스트(product.getStocks())를 변경하지 않음
• 병렬 처리 가능 (.parallelStream()으로 성능 최적화 가능)
• 함수형 스타일로 가독성이 좋음

 

🔹작동 방식
1️⃣ product.getStocks().stream() → Stock 리스트를 스트림으로 변환
2️⃣ .map(stock -> new ProductStockDto(...)) → Stock 객체를 ProductStockDto로 변환
3️⃣ .collect(Collectors.toList()) → 변환된 DTO 리스트로 수집

 

✅8-2. for 루프 사용 방식

List<ProductDetailDTO.ProductStockDto> stockDTOs = new ArrayList<>();
for (int i = 0; i < product.getStocks().size(); i++) {
    ProductStocks stock = product.getStocks().get(i);
    ProductDetailDTO.ProductStockDto dto = new ProductDetailDTO.ProductStockDto();
    dto.setSizeName(stock.getSize().getSizeName());
    dto.setColorName(stock.getColor().getColorName());
    dto.setStockQuantity(stock.getStockQuantity());
    stockDTOs.add(dto);
}

 

🔹 특징

• 명확한 절차적 접근 → 디버깅이 쉬움
• .stream() 없이 기본적인 for 반복문 사용
• 변수 조작 가능 (반복 중 특정 조건에서 추가 처리 가능)
• 성능 차이는 거의 없음 (Stream은 내부적으로 최적화됨)

 

🔹 작동 방식
1️⃣ new ArrayList<>() 로 빈 리스트 생성
2️⃣ for 루프를 돌며 Stock 객체 하나씩 가져옴
3️⃣ new ProductStockDto()로 DTO 생성
4️⃣ setXXX()으로 필드 값 설정
5️⃣ stockDTOs.add(dto)로 리스트에 추가

 

🚀 Stream API 언제 써야 할까?

✅ 데이터 필터링, 변환, 수집을 효율적으로 처리할 때
✅ 가독성을 높이고 코드 길이를 줄이고 싶을 때
✅ 대량 데이터를 병렬 처리(parallelStream())하고 싶을 때

❌ 단순 반복문보다 성능이 중요할 경우 (for 문이 더 빠를 수도 있음)

📌 9. for, stream, stream+병렬처리 성능

💡 성능 비교 기준

1️⃣ 컬렉션 크기 - 데이터 개수가 많아질수록 stream()이 유리해질 가능성이 높음
2️⃣ 연산의 복잡도 - 연산이 가벼우면 for 문이 빠르고, 연산이 무거우면 stream()이 유리함
3️⃣ 병렬 처리가 가능한가? - CPU-intensive(연산량이 많은) 작업이면 parallelStream()이 유리

 

🔥 for vs stream() vs parallelStream() 추천

상황	for 문	stream()	parallelStream()
데이터 크기	작은 경우 유리 (100개 이하)	중간 크기 (1,000개 이상)	매우 큰 경우 (100,000개 이상)
연산 복잡도	단순 연산	보통 연산 (필터링, 변환 등)	연산이 매우 무거운 경우
병렬 처리 필요	❌ 지원 안됨	❌ 단일 스레드	✅ 다중 스레드
가독성	다소 길어짐	✅ 간결하고 직관적	🚨 코드가 복잡해질 수 있음
추천 예제	단순 합산, 인덱스 기반 반복	데이터 필터링, 변환	머신러닝, 대용량 데이터 처리

 

✅9-1. for 문이 더 빠른 경우 (작은 데이터 + 간단한 연산)

• 컬렉션 크기가 작음 (예: 100개 이하)
• 연산이 간단함 (ex. 단순한 덧셈, 곱셈, 대입 연산)
• 상태를 직접 조작해야 하는 경우 (ex. 인덱스 기반 접근이 필요할 때)

 

📖 예제: for 문이 빠른 경우

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (int num : numbers) {
    sum += num;
}

System.out.println(sum); // 15

 

➡️ for 문이 단순한 루프일 때는 stream보다 성능이 더 좋음

 

✅9-2. stream()이 더 유리한 경우 (큰 데이터 + 복잡한 연산)

• 컬렉션 크기가 큼 (예: 10,000개 이상)
• 데이터 필터링, 변환, 정렬이 많을 때
• 가독성이 중요한 경우 (코드가 짧고 간결해짐)
• 단일 스레드에서 실행해도 효율적인 경우

 

📖 예제: stream()이 유리한 경우 (데이터 필터링 + 변환)

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());

System.out.println(filteredNames); // [ALICE]

 

➡️ 복잡한 연산이 포함된 경우 stream()이 가독성이 좋고 효율적

 

✅9-3. parallelStream()이 유리한 경우 (대량 데이터 + 연산이 무거운 경우)

• CPU-intensive 작업에서 유리함!
• 데이터 크기가 매우 큼 (예: 100,000개 이상)
• 각 요소의 연산 시간이 오래 걸리는 경우
• 컬렉션이 쉽게 나눌 수 있는 구조(Splittable Collection, ex. ArrayList, HashSet)

 

⚠️ 주의! parallelStream()이 무조건 빠른 것은 아님

•  병렬 처리 오버헤드가 있기 때문에 작은 데이터에서는 for 문보다 느릴 수 있음

➡️ 데이터 수가 적을 때:  스레드를 나누는 비용 > 계산 비용이기 때문

•  LinkedList, TreeSet 같은 자료구조는 내부적으로 split이 어려워 병렬 처리에 적합하지 않음
• 상태를 공유하는 연산 (stateful operation)은 병렬 스트림에서 예상치 못한 동작이 발생할 수 있음
• Cpu 성능에도 영향.

 

📖 예제: parallelStream()이 유리한 경우 (무거운 연산 포함)

List<Integer> numbers = IntStream.range(1, 1_000_000).boxed().collect(Collectors.toList());

long startTime = System.currentTimeMillis();
int sum1 = numbers.stream()
                  .map(n -> n * n)  // 제곱 연산
                  .reduce(0, Integer::sum);
long endTime = System.currentTimeMillis();

System.out.println("Stream 실행 시간: " + (endTime - startTime) + "ms");

startTime = System.currentTimeMillis();
int sum2 = numbers.parallelStream()
                  .map(n -> n * n)
                  .reduce(0, Integer::sum);
endTime = System.currentTimeMillis();

System.out.println("Parallel Stream 실행 시간: " + (endTime - startTime) + "ms");

 

➡️ 연산이 무거울수록 parallelStream()이 성능이 더 좋음!

 

✅9-4. 성능 예측: 순회비용과 계산비용

순회비용과 계산비용을 알면 for, stream, parallelStream 중 뭐가 더 유리한지 어느정도 예측할 수 있다.

 

예를 들어, 

단순 계산일 때, 순회비용이 커지면 for > stream 격차가 줄어든다.

계산비용이 커질 수 록 stream이 유리해진다.

 

✅9-4-1. 순회비용과 계산비용의 의미

요소	의미	예시
순회비용	데이터를 하나씩 가져오는 데 드는 비용	리스트의 크기, 자료구조 특성
계산비용	데이터를 처리하는 데 드는 비용	.map(), .filter(), 복잡한 계산 등

💡 순회비용에 영향을 주는 요소

• 자료구조의 구조
• 크기 (n 개 항목이면 O(n))
• 순회 방식 (Index 기반 vs Iterator 기반 등)

 

✅ 9-4-2. 비용 계산

💡 총 처리 시간 (T) = 순회비용(Ci) + 계산비용(Cf) + 오버헤드(O)

 

1️⃣For: 순회도 직접, 계산도 직접 (오버헤드 없음)

 T = Ci + Cf

 

2️⃣stream: 내부 순회 + 함수형 처리 + 약간의 오버헤드(파이프라인 구성 등)

T = Ci * α + Cf * β + O1 // (α, β는 stream 내부 처리의 오버헤드 계수)

 

3️⃣parallelStream: 병렬화로 순회와 계산 분산 + 병렬 오버헤드 (스레드, 분할 등)

T = (Ci + Cf) / N + O2 // (N = 코어 수)

 

✅ 9-4-3. 실제로 시간 측정하는 예시 코드

long start = System.nanoTime();
for (int i = 0; i < list.size(); i++) {
    slowOperation(list.get(i)); // 계산비용
}

long end = System.nanoTime();
System.out.println("for: " + (end - start) / 1_000_000 + "ms");

start = System.nanoTime();
list.stream().forEach(item -> slowOperation(item));
end = System.nanoTime();
System.out.println("stream: " + (end - start) / 1_000_000 + "ms");

start = System.nanoTime();
list.parallelStream().forEach(item -> slowOperation(item));
end = System.nanoTime();
System.out.println("parallelStream: " + (end - start) / 1_000_000 + "ms");s

 

✅🚀 9-4-4. 성능 예측 결론

순회비용(Ci)	계산비용(Cf)	유리한 방식
낮음	낮음	for (오버헤드 없음, 가장 가볍다)
낮음	높음	parallelStream() (계산 병렬화 유리)
높음	낮음	자료구조 따라 다름 (stream이 최적화된 경우 유리)
높음	높음	parallelStream() (둘 다 병렬 최적화 가능)

* 성능 비교 참고 자료

https://sigridjin.medium.com/java-stream-api%EB%8A%94-%EC%99%9C-for-loop%EB%B3%B4%EB%8B%A4-%EB%8A%90%EB%A6%B4%EA%B9%8C-50dec4b9974b