🔄 자바 Stream API 가이드 - 생성, 연산, 장단점 정리

1. Stream API

Stream API는 Java 8에서 도입된 기능으로 컬렉션 데이터를 함수형 프로그래밍 스타일로 처리하기 위해 제공되는 API이다. 기존의 for문이나 Iterator를 이용한 외부 반복 방식 대신 내부 반복 방식을 사용하여 코드의 가독성과 유지보수성을 향상시킨다.

// for문
for (String name : names) {
  if (name.length() > 4) {
    System.out.println(name.toUpperCase());
  }
}

// Stream
names.stream()
     .filter(n -> n.length() > 4)
     .map(String::toUpperCase)
     .forEach(System.out::println);

- 주요 특징

• 선언형 처리
  어떻게 처리할지보다 무엇을 할지를 표현하는 방식이다. 이로 인해 코드가 간결하고 직관적으로 작성될 수 있다.
• 데이터 불변성
  원본 데이터를 변경하지 않고 새로운 결과 스트림을 생성한다. 따라서 데이터의 안정성이 유지되며 병렬 처리에 유리하다.
• 지연 연산
  중간 연산은 실제 결과가 필요할 때까지 실행되지 않는다. 최종 연산이 호출될 때 전체 스트림 파이프라인이 실행된다.
• 내부 반복
  반복 처리를 Stream 라이브러리가 내부적으로 수행한다. 따라서 개발자가 직접 반복 구조를 작성할 필요가 없다.

2. 스트림 파이프라인 구​조

Stream API는 연속된 데이터 처리 과정을 파이프라인 형태로 연결하여 수행한다. 스트림 파이프라인은 일반적으로 스트림 생성 -> 중간 연산 -> 최종 연산의 세 단계로 구성된다.

- 스트림 생성 (Source)

컬렉션, 배열, 파일 등의 데이터 소스로부터 스트림 객체를 생성한다. Java에서는 다양한 방법으로 Stream을 생성할 수 있다. 

// 1. 컬렉션에서 생성
List<String> list = List.of("Blue", "Cool", "Good");
Stream<String> stream1 = list.stream();

// 2. 배열에서 생성
String[] arr = {"This", "is", "Array"};
Stream<String> stream2 = Arrays.stream(arr);

// 3. 숫자 범위에서 생성
IntStream intStream = IntStream.range(1, 5);
LongStream longStream = LongStream.rangeClosed(1, 5);

// 4. 직접 생성
Stream<Double> randoms = Stream.generate(Math::random).limit(5);

// 5. 빌더 사용
Stream<String> buildStream = Stream.<String>builder()
  .add("This")
  .add("is")
  .add("Builder")
  .build();

- 중간 연산 (Intermediate Operations)

데이터를 변환, 필터링, 정렬하는 과정을 담당하며 Stream 파이프라인의 중간 단계에서 수행되는 연산이다. 이 과정에서 지연 연산(Lazy Evaluation)이 발생한다.

지연 연산이란 최종 연산이 호출되기 전까지 실제 연산이 수행되지 않고 최종 연산이 실행되는 시점에 전체 파이프라인이 한 번에 처리되는 방식을 의미한다.

또한 중간 연산은 Stream 객체를 반환하기 때문에 여러 연산을 연결하는 체이닝 방식으로 사용할 수 있다. 이를 통해 여러 데이터 처리 과정을 하나의 파이프라인으로 구성할 수 있다.

대표적인 중간 연산 메서드는 다음과 같다.

filter(Predicate)             // 조건에 맞는 요소만 필터링
map(Function)                 // 요소를 다른 형태로 변환
flatMap(Function)             // 중첩된 구조를 평탄화
sorted() / sorted(Comparator) // 요소 정렬
distinct()                    // 중복 제거
limit(long)                   // 앞에서부터 n개 요소 선택
skip(long)                    // 앞에서부터 n개 요소 건너뜀
peek(Consumer)                // 요소를 소비하지 않고 중간 처리 과정 확인

- 최종 연산 (Terminal Operation)

스트림 파이프라인의 마지막 단계에서 수행되는 연산으로 중간 연산을 통해 처리된 데이터를 최종 결과로 반환하거나 소비하는 역할을 한다.

최종 연산이 호출되면 그때까지 정의된 중간 연산들이 한 번에 실행되면서 스트림 파이프라인이 종료된다. 또한 최종 연산이 수행된 스트림은 재사용할 수 없다.

대표적인 최종 연산 메서드는 다음과 같다. 

forEach(Consumer)                 // 각 요소를 순회하며 처리
collect(Collector)                // 스트림 요소를 컬렉션 등으로 변환
toArray()                         // 스트림 요소를 배열로 변환
reduce(BinaryOperator)            // 요소를 누적 연산하여 하나의 결과로 반환
count()                           // 요소의 개수 반환
findFirst()                       // 첫 번째 요소 반환
findAny()                         // 요소 중 하나를 반환 (병렬 처리 시 주로 사용)
allMatch(Predicate)               // 모든 요소가 조건을 만족하는지 확인
anyMatch(Predicate)               // 하나라도 조건을 만족하는지 확인
noneMatch(Predicate)              // 조건을 만족하는 요소가 없는지 확인
min(Comparator)                   // 최소값 반환
max(Comparator)                   // 최대값 반환

스트림 생성부터 연산까지의 흐름은 다음과 같다. 

List<String> names = List.of("BlueCool", "PYO", "MIN", "BlueMin");

// 길이가 4보다 큰 이름만 필터링 -> 대문자로 변환 -> 알파벳순 정렬 -> 출력
names.stream()                       // 스트림 생성 (Source)
  .filter(name -> name.length() > 4) // 중간 연산: 조건 필터링 (Predicate)
  .map(String::toUpperCase)          // 중간 연산: 문자열을 대문자로 변환 (Function)
  .sorted()                          // 중간 연산: 알파벳순 정렬
  .forEach(System.out::println);     // 최종 연산: 요소 출력 (Consumer)

3. 기본형 스트림 (Primitive Stream)

Stream API는 매우 편리한 기능이지만 모든 상황에서 항상 최선의 선택은 아니다. 데이터의 크기가 작거나 연산이 단순한 경우에는 기존의 반복문이 더 직관적이거나 성능 면에서 유리할 수도 있다.

또한 기본형이 아닌 객체를 사용할 경우 박싱(Boxing)과 언박싱(Unboxing) 과정에서 불필요한 오버헤드가 발생할 수 있다. 이러한 성능 문제를 줄이기 위해 Java에서는 기본형 전용 스트림을 제공한다.

대표적인 기본형 스트림은 다음과 같다.

• IntStream
• LongStream
• DoubleStream

이러한 기본형 스트림을 사용하면 기본 타입을 직접 처리할 수 있어 불필요한 객체 생성과 박싱/언박싱 비용을 줄일 수 있다.

// 1부터 9까지의 숫자 중 짝수만 선택한 뒤 합계를 구하는 예시
IntStream.range(1, 10)
        .filter(n -> n % 2 == 0)
        .sum();                         

숫자 연산에서 보다 효율적인 스트림 처리가 가능하다.

4. 병렬 스트림 (Parallel Stream)

Stream API는 데이터를 병렬로 처리할 수 있는 기능을 제공한다. 이를 통해 여러 CPU 코어를 활용하여 데이터 처리를 동시에 수행할 수 있다.

병렬 스트림은 parallelStream() 또는 parallel() 메서드를 사용하여 생성할 수 있다.

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

// 병렬 스트림 생성
numbers.parallelStream()
       .map(n -> n * 2)
       .forEach(System.out::println);

또는 기존 스트림에 parallel()을 호출하여 병렬 스트림으로 전환할 수도 있다.

numbers.stream()
       .parallel()
       .map(n -> n * 2)
       .forEach(System.out::println);

​병렬 스트림은 데이터의 크기가 크고 연산량이 많은 경우 성능 향상에 도움이 될 수 있다. 하지만 연산이 단순하거나 데이터의 크기가 작은 경우, 동기화가 필요한 경우, 순서가 중요한 연산인 경우에는 오히려 성능이 저하될 수 있다.

따라서 병렬 스트림은 데이터의 특성과 연산의 복잡도를 고려하여 적절하게 사용하는 것이 중요하다.