[Java] Stream

Collection 각각의 요소에 함수형 프로그래밍을 도입

---

Java 8의 Stream

Stream의 등장 이유: Collection 각각의 요소에 대한 함수형 프로그래밍을 도입하자

Stream은 Java 8에서 도입된 함수형 프로그래밍 도구로, 기존 컬렉션 처리 방식의 한계를 해결하기 위해 등장했다.

기존에는 for, while 같은 외부 반복을 사용해 컬렉션 요소를 처리했지만, Stream은 이러한 처리를 내부에서 수행하여 더 간결하고 유연하게 만든다.

• 외부 반복: 루프를 통해 외부에서 컬렉션 요소를 처리.
• 내부 반복: Stream을 사용해 내부에서 컬렉션 요소를 처리.

---

• Stream 이전의 자바 컬렉선 처리 방식 (외부 반복):

for (String string : list) {
    if (string.contains("a")) {
        return true;
    }
}

- Stream이 등장하기 전의 자바에서는 `for` 문법을 통해 이터레이션.

• Stream을 사용한 컬렉션 처리 방식(내부 반복):

boolean isExist = list.stream().anyMatch(element -> element.contains("a"));

- Stream이 등장한 후에는 간단하게 함수형 프로그래밍(함수형 인자)으로 내부 이터레이션.

Stream: Collection 각각 요소에 대한 함수형 프로그래밍 처리 단위

Stream은 컬렉션의 데이터를 함수형 프로그래밍으로 처리할 수 있도록 하는 객체이다. 이를 통해 컬렉션 내 요소들을 간결하게 변환, 필터링, 집계 등의 작업을 수행할 수 있다.

• 변수 선언: Stream<String>: Generic 제네릭을 통해 어떤 타입의 요소를 가질 수 있는지 명시
• 객체 생성: Array로 부터 Stream 생성 / List로 부터 Stream 생성 / Stream 직접 생성

1. Array로 부터 Stream 생성

String[] arr = new String[]{"a", "b", "c"};
Stream<String> stream = Arrays.stream(arr);

2. List로 부터 Stream 생성(가장 일반적인 사용 방식)

List<String> lists = Arrays.asList("a", "b", "c");
Stream<String> stream = lists.stream();

3. Stream 직접 생성

Stream<String> stream = Stream.of("a", "b", "c");

 

함수형 프로그래밍 에서 Stream의 장점

• 선언형: 코드를 더 간결하고 가독성 높게 작성할 수 있다.
• 조립 가능: 여러 연산을 체인처럼 연결할 수 있어 유연성 증가
• 병렬화: 간단한 설정으로 병렬 처리가 가능해 성능이 향상.

Stream 사용

Stream에서의 연산은 Intermediate Operations(중간 연산)과 Terminal Operations(종료 연산) 로 나눌 수 있다.

 

Intermediate Operations(중간 연산)

 

중간 연산은 Stream을 반환하여 계속해서 체이닝할 수 있다.

• Mapping(`.map()`): 각 요소를 다른 값으로 변환한다. 타입 변환도 가능하다. 

List<String> names = Arrays.asList("John", "Jane", "Jack");
List<Integer> nameLengths = names.stream()
    .map(String::length)
    .collect(Collectors.toList()); // [4, 4, 4]

• Filtering (`.filter()`): 조건을 만족하는 요소들만 필터링하여 남긴다.

List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("J"))
    .collect(Collectors.toList()); // ["John", "Jane", "Jack"]

 

Terminal Operations(종료 연산)

종료 연산은 Stream을 종료하고 최종 결과를 반환한다.

 

Matching:

• `.anyMatch()`: 조건을 만족하는 요소가 하나라도 있는지 확인한다.

boolean hasJane = names.stream().anyMatch(name -> name.equals("Jane"));

• `.allMatch()`: 모든 요소가 조건을 만족하는지 확인한다.

boolean allNamesStartWithJ = names.stream().allMatch(name -> name.startsWith("J"));

• `.noneMatch()`: 조건을 만족하는 요소가 없는지 확인한다.

boolean noNamesWithZ = names.stream().noneMatch(name -> name.contains("Z"));

 

 

Reduction:

• `.reduce()`: 여러 요소를 하나로 합쳐 단일 값을 반환한다.

int sum = Arrays.asList(1, 2, 3, 4).stream().reduce(0, Integer::sum);

 

Collecting

• `.collect()`: 요소들을 Collection으로 변환하여 반환한다.

List<String> collectedNames = names.stream().collect(Collectors.toList());

 

Stream 활용

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 0)  // 짝수만 필터링
                 .mapToInt(n -> n * 2)     // 2배로 변환
                 .sum();                   // 합계 계산

위 예제 코드는 짝수만 필터링하고 2배로 변환한 후, 그 값들의 합계를 구하는 간단한 활용법이다.

 

Java 9에서 추가된 Stream 메서드

1. takeWhile(): 조건을 만족할 떄까지 요소를 가져온다.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = numbers.stream()
    .takeWhile(n -> n < 4)
    .collect(Collectors.toList()); // [1, 2, 3]

 

2. dropWhile(): 조건을 만족하는 동안 요소를 버리고, 이후의 요소만을 가져온다.

List<Integer> result = numbers.stream()
    .dropWhile(n -> n < 4)
    .collect(Collectors.toList()); // [4, 5]

 

3. iterate(): 초기값과 조건을 함께 사용하여 반복적인 Stream을 생성할 수 있다.

Stream<Integer> stream = Stream.iterate(1, n -> n < 10, n -> n + 1);
stream.forEach(System.out::println); // 1부터 9까지 출력

 

---

ℹ️참고

[ASAC 6기 강의자료]