5장: 스트림 활용

스트림이 지원하는 다양한 연산을 배워보자.

이번 장에서는 아래 메서드들을 차근차근 살펴본다. 🐳

필터링

Predicate 필터링

filter 메서드는 Predicate(boolean을 반환하는 함수형 인터페이스)를 인수로 받아서 Predicate에서 true를 반환하는 요소만 포함하는 스트림을 반환한다.

List<Integer> numbers = List.of(1,2,4,2,3,5);
numbers.stream()
       .filter(i -> i % 2 == 0)
       .forEach(System.out::println);

고유 요소만 필터링

고유 요소로 이루어진 스트림을 반환하는 distinct메서드도 지원한다.
객체의 고유 여부는 스트림에서 만든 객체의 hashCode, equals로 결정한다. (equals & hashcode를 잘 정의해하도록 하자..🥲)

List<Integer> numbers = List.of(1,2,4,2,3,5);
numbers.stream()
       .filter(i -> i % 2 == 0)
       .distinct() // 중복 필터링
       .forEach(System.out::println);

스트림 슬라이싱

스트림의 요소를 선택하거나 스킵하는 방법

Predicate를 이용한 슬라이싱

TAKEWHILE

데이터가 정렬되어 있고, 특정 조건이 참이 나오면 반복 작업을 중단하려면 takeWhile()을 이용해 처리할 수 있다.
filter는 모든 데이터를 검사하며 true인 것만 다음으로 넘어가지만, takeWhile은 조건에 대해 true가 아니게 될 경우 바로 거기서 멈추게 된다.
아래 예제는 320 칼로리 미만인 메뉴만 슬라이싱한다.

List<Dish> silcedMenu = specialMenu.stream()
                                   .takeWhile(dish -> dish.getCalories() < 320)
                                   .collect(toList());

DROPWHILE

takeWhile과 정반대로, 데이터가 정렬되어 있고, 특정 조건이 거짓이 나오면 반복 작업을 중단하려면 dropWhile()을 이용해 처리할 수 있다.
프레디케이트가 처음으로 거짓이 되는 지점까지 탐색한 후, 작업을 중단하고 해당 지점 이후의 탐색하지 않은 모든 요소를 반환한다.
아래 예제는 320 칼로리 이상인 메뉴만 슬라이싱한다.

List<Dish> silcedMenu = specialMenu.stream()
                                   .dropWhile(dish -> dish.getCalories() < 320)
                                   .collect(toList());

스트림 축소

주어진 값 이하의 크기를 갖는 새로운 스트림을 반환하는 limit(n) 메서드를 사용할 수 있다.
최대 n개의 요소만을 반환할 수 있다.
아래는 최대 3개의 요소만을 반환하도록 하는 코드이다.

List<Dish> silcedMenu = specialMenu.stream()
                                   .filter(dish -> dish.getCalories() > 300)
                                   .limit(3)
                                   .collect(toList());

요소 건너뛰기

처음 n개 요소를 제외한 스트림을 반환하는 skip(n) 메서드를 제공한다.
n개 이하의 요소를 포함하는 스트림에 skip(n)을 호출하면 빈 스트림이 반환된다.
limit과 skip은 상호 보완적인 연산을 수행한다.
아래는 300칼로리 이상인 음식 중 처음 두 요리는 스킵하고 나머지 요리들만 반환하는 코드이다.

List<Dish> silcedMenu = specialMenu.stream()
                                   .filter(dish -> dish.getCalories() > 300)
                                   .skip(2)
                                   .collect(toList());

매핑

특정 객체에서 특정 데이터를 선택하기 위해 매핑 작업을 수행할 수 있다.

스트림의 각 요소에 함수 적용하기

함수를 인수로 받는 map 메서드를 지원한다.
인수로 제공된 함수는 각 요소에 적용되며 함수를 적용한 결과가 새로운 요소로 매핑된다.
다음은 Dish 리스트를 스트림으로 순회하며 Dish의 name 필드만 추출한 리스트를 반환하는 코드이다.

List<String> MenuNames = specialMenu.stream()
                                    .map(Dish::getName)
                                    .collect(toList());

다른 map 메서드를 체이닝하는 것도 가능하다.
다음은 Dish 리스트를 스트림으로 순회하며 name필드의 길이를 추출한 리스트를 반환하는 코드이다.

List<Integer> MenuNameLengths = specialMenu.stream()
                                           .map(Dish::getName)
                                           .map(String::length)
                                           .collect(toList());

스트림 평면화

flatMap은 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다.
스트림의 각 값을 다른 스트림으로 만든 다음에, 모든 스트림을 하나의 스트림으로 연결하는 기능을 수행한다.
아래 코드의 flatMap은 단어들을 모두 알파벳 단위로 떼어낸 후 얻는 여러 개의 String[] 배열들을 하나의 String Stream으로 모아 순회할 수 있도록 해준다.

List<String> uniqueChars = words.stream()
                                .map(word -> word.split("")) // Stream<String[]>
                                .flatMap(Arrays::stream) // Stream<String>
                                .distinct()
                                .collect(toList());

검색과 매칭

적어도 한 요소와 일치하는지 검사

Predicate가 주어진 스트림에서 적어도 한 요소와 일치하는지 확인할 때 anyMatch 메서드를 활용한다.

boolean isMatch = menu.stream().anyMatch(Dish::isVegetarian);

모든 요소와 일치하는지 검사

Predicate가 주어진 스트림의 모든 요소와 일치하는지 확인할 때 allMatch 메서드를 활용한다.

boolean isAllVegiterian = menu.stream().allMatch(Dish::isVegetarian);

Predicate가 주어진 스트림의 모든 요소와 일치하지 않는지 확인할 때 noneMatch 메서드를 활용한다.

boolean isHealthy = menu.stream().noneMatch(d -> d.getCalories() >= 1000);

쇼트 서킷
하나라도 조건에 맞지 않는다면 나머지 표현식의 결과에 상관없이 전체 결과가 정해지기 때문에 전체 스트림을 처리하지 않아도 결과를 반환할 수 있는 것을 말한다.
allMatch, noneMatch, findFirst, findAny 등의 연산이 모두 이에 해당한다.

요소 검색

findAny 메서드는 현재 스트림에서 임의의 요소를 반환한다.
다른 스트림 연산과 연결해서 사용할 수 있으며, 결과를 찾는 즉시 스트림을 종료한다.
findFirst 메서드를 사용할 경우 병렬 실행 시 첫 번째 요소를 찾기 어려우므로 보통 병렬으로 실행시킬 때 제약이 적은 findAny 메서드를 사용한다.

Optional<Dish> dish = words.stream()
          .filter(Dish::isVegetarian)
          .findAny();

첫 번째 요소 찾기

스트림은 첫번째 요소를 찾는 findFirst 메서드를 제공한다.
리스트 또는 정렬된 데이터로부터 생성된 스트림은 논리적인 아이템 순서가 정해져 있을 수 있다.

Optional<Integer> first = someNumbers.stream()
        .map(n -> n * n)
        .filter(n -> n % 3 == 0)
        .findFirst();

리듀싱

스트림의 최종연산 중 하나로 마지막 결과가 나올때까지 스트림의 모든 요소를 반복적으로 처리하는 과정
함수형 프로그래밍 언어 용어로는 이과정이 마치 종이를 작은 조각이 될때까지 반복해서 접는것과 비슷하다 하여 폴드(fold)라고 부른다.
리듀스의 파라미터
- 초깃값
- 스트림의 두 요소를 조합해 새로운 값을 만드는 BinaryOperator<T> 의 구현체(람다)
reduce를 사용하면 스트림이 하나의 값으로 줄어들 때 까지 각 요소를 반복해 조합하기 때문에, 애플리케이션의 반복된 패턴을 추상화 할 수 있다.

요소의 합

reduce를 사용해 스트림의 모든 요소들의 총합을 구해보자.
초깃값을 0으로 두고, 더하기 메서드를 파라미터로 넘기면 스트림에 총합만 남을때까지 더하는 연산이 수행된다.

// 기존 자바 방식
int sum = 0;
for ( int x : numbers ) {
  sum += x;
}

// 스트림의 리듀스 사용
int sum = numbers.stream().reduce(0, (a, b) -> a + b);
int multiple = numbers.stream().reduce(1, (a, b) -> a * b); // 모든 요소를 곱하므로 초깃값은 1이어야 한다.

// 메서드 참조
int sum = numbers.stream().reduce(0, Integer::sum);

리듀스 연산에 초깃값을 주지 않으면 스트림에 아무 요소도 없는 경우 값을 반환할 수 없기 때문에 Optional 객체로 감싼 결과를 반환한다.

최댓값과 최솟값

최댓값과 최솟값을 찾을 때도 reduce를 활용할 수 있다.
스트림의 모든 요소를 소비할 때 까지 max() 혹은 min() 연산을 한다.

Optional<Integer> max = numbers.stream().reduce(Integer::max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);

reduce 메서드와 병렬화
reduce를 이용하면 내부 반복이 추상화되면서 포크/조인 프레임워크를 활용해 병렬로 reduce를 실행할 수 있게 된다.
단계적 반복으로 합계를 구할때는 sum 변수를 공유해야 하는데, 이로 인해 동기화 이슈가 발생해 병렬화가 어렵다.
물론 병렬로 실행하기 위해서는 연산이 어떤 순서로 실행되더라도 결과가 바뀌지 않는 구조여야 한다.

스트림 연산 : 상태 있음과 상태 없음
상태 없음 (stateless operation)
map, filter 등은 입력 스트림에서 각 요소를 받아 0 또는 결과를 출력 스트림으로 보낸다.
상태 있음 (stateful operation)
reduce, sum, max 같은 연산은 결과를 누적할 내부 상태가 필요하지만 이는 int, double 등과 같이 작은 값이며, 스트림에서 처리하는 요소 수와 관계없이 한정(bounded)되어있다.
반면 sorted나 distinct 같은 연산을 수행하기 위해서는 과거의 이력을 알고있어야 한다. 예를 들어 어떤요소를 출력 스트림으로 추가하려면 모든 요소가 버퍼에 추가되어 있어야 한다. 따라서 데이터 스트림의 크기가 크거나 무한이라면 문제가 생길 수 있다.

숫자형 스트림

3장 내용과 비슷하게 오토박싱을 피하기 위해 primitive type을 위한 스트림을 제공한다.
int 요소에 특화된 IntStream, double 요소에 특화된 DoubleStream, long 요소에 특화된 LongStream을 제공한다.

숫자 스트림으로 매핑

mapToInt, mapToDouble, mapToLong 메서드를 사용하면 기본형 특화 스트림으로 변환해준다.
아래와 같이 mapToInt 메서드로 각 요리에서 모든 칼로리(Interger형식)를 추출한 다음에 IntStream을(Stream<Integer>가 아님) 반환한다. 스트림이 비어있으면 sum은 기본값 0을 반환한다.

int calories = menu.stream()
                   .mapToInt(Dish::getCalories) // IntStream
                   .sum();

객체 스트림으로 복원

숫자 스트림을 기본 스트림으로 변환하려면 boxed() 메서드를 사용하면 된다.

IntStream intStream = menu.stream().mapToInt(Dish::getCalories);
Stream<Integer> stream = intStream.boxed();

OptionalInt

Optional을 Integer, String 등의 참조 형식으로 파라미터화할 수 있다.
OptionalInt, OptionalDouble, OptionalLoing 세 가지 기본형 특화 스트림 버전을 제공하여 숫자 스트림 메서드의 결과를 받을 수 있다.

OptionalInt maxCalories = menu.stream().mapToInt(Dish::getCalories).max();
int max = maxCalories.orElse(1);

숫자 범위

IntStream과 LongStream에서는 range와 rangeClosed라는 두 가지 정적 메서드를 제공한다. 두 메서드 모두 시작값과 종료값을 인수로 가진다.
range 메서드는 시작값과 종료값이 결과에 포함되지 않는다.
rangeClosed 메서드는 시작값과 종료값이 결과에 포함된다.

IntStream evenNumbers = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);
System.out.println(evenNumbers.count()); // 50 출력

피타고라스의 수를 구하는 예제

1부터 100까지 피타고라스의 수를 구한다. (a*a + b*b = c*c인 경우의 수를 모두 구하기)
a, b를 iteration 돌면서 a*a + b*b 의 제곱근이 정수일 경우에만 int[a, b, c]를 스트림에 남겨둔다.

Stream<int[]> pythagoreanTriples = 
   IntStream.rangeClose(1, 100).boxed()
            .flatMap(a -> 
                     IntStream.rangeClose(a, 100)
                              .mapToObj(b -> new int[]{a, b, (int)Math.sqrt(a * a + b * b)})
                              .filter(t -> t[2] % 1 == 0));

다양하게 스트림 만들기

값으로 스트림 만들기

임의의 수를 인수로 받는 정적 메서드 Stream.of를 이용해서 스트림을 만들 수 있다.

Stream<String> stream = Stream.of("Modern", "Java", "In", "Action");

Stream.empty() 메서드는 스트림을 비운다.

Stream<String> emptyStream = Stream.empty();

null이 될 수 있는 객체로 스트림 만들기

ofNullable 메서드로 null이 될 수 있는 객체를 포함하는 스트림을 만들 수 있다.
nullable한 객체를 포함하는 스트림값과 flatMap을 함께 사용하는 상황에서 유용하게 사용할 수 있다.

Stream<String> stream = Stream.ofNullable(System.getProperty("home"));

Stream<String> values = Stream.of("config", "home", "user")
   .flatMap(key -> Stream.ofNullable(System.getProperty(key)));

배열로 스트림 만들기

배열을 인수로 받는 정적 메서드 Arrays.stream()을 이용해서 스트림을 만들 수 있다.

int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();

파일로 스트림 만들기

파일을 처리하는 등의 I/O 연산에 사용하는 자바의 NIO API(비블록 I/O)도 스트림 API를 활용할 수 있다.
Files.lines로 파일의 각 행 요소를 반환하는 스트림을 얻을 수 있다.
Stream 인터페이스는 AutoCloseable 인터페이스를 구현하므로, try 블록 내의 자원은 자동으로 관리된다.
다음은 입력받은 파일에서 각 행의 단어들을 flatMap으로 하나의 스트림으로 평면화한 후, 고유한 단어가 몇개인지 반환하는 코드이다.

long uniqueWords = 0;
try(Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
  uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
    .distinct()
    .count();
} catch (IOException e) {
  // 파일 열다가 예외 발생 시 처리
}

함수로 무한 스트림 만들기

Stream.iterate와 Stream.generate를 이용해서 함수로부터 크기가 고정되지 않은 무한 스트림(unbounded stream)을 만들 수 있다.

iterate 메서드

초깃값과 람다를 인수로 받아서 새로운 값을 끊임없이 생산할 수 있다.
보통은 무한한 값을 출력하지 않도록 limit(n) 메서드와 함께 사용한다.
혹은 두 번째 인수로 Predicate를 받아 작업 중단의 기준으로 사용할 수도 있다.

Stream.iterate(0, n -> n + 2)
   .limit(10)
   .forEach(System.out::println);

// 100보다 큰 값이 나오면 작업 중단
IntStream.iterate(0, n -> n < 100, n -> n + 4)
         .forEach(System.out::println);

filter 메서드는 언제 작업을 중단할 지 알릴 수 없기 때문에, takeWhile 메서드를 사용해야 한다.

IntStream.iterate(0, n -> n + 4)
         .takeWhile(n -> n < 100)
         .forEach(System.out::println);

generate 메서드

iterate와 달리 generate는 생산된 각 값을 연속적으로 계산하지 않으며, Supplier<T>를 인수로 받아서 새로운 값을 생산한다.
아래 코드는 0에서 1 사이의 임의의 double number 5개를 만든다.

Stream.generate(Math::random)
      .limit(5)
      .forEach(System.out::println);

generate 메서드의 경우 Supplier에 상태를 가질 가능성이 높아지므로, 순수한 불변 상태를 유지하는 iterate 메서드에 비해 병렬 환경에서 불안정하다.

Previous4장: 스트림 Next6장: 스트림으로 데이터 수집

Last updated 9 months ago