#05장 스트림 활용

Raoul-Gabriel Urma 저, 우정은 역 「Modern Java in Action, 2019」를 읽고 정리하였습니다.

이 장의 주요 내용

• 필터링, 슬라이싱, 매칭

• 검색, 매칭, 리듀싱

• 특정 범위의 숫자와 같은 숫자 스트림 사용하기

• 다중 소스로부터 스트림 만들기

• 무한 스트림

1 데이터 컬렉션 반복을 명시적으로 관리할 경우 코드 2 스트림 API 사용시 컬렉션 반복을 내부적으로 처리

// 1
List<Dish> vegetarianDishes = new ArrayList<>();
for(Dish d: menu) {
    if(d.isVegetarian()){
        vegetarianDishes.add(d);
    }
}
// 2
import static java.util.stream.Collectors.toList;
List<Dish> vegetarianDishes =
    menu.stream()
    .filter(Dish::isVegetarian)
    .collect(toList());

더편리하고 내부반복에 더해 병렬도 가능 (외부반복은 병렬 불가)

이 장에서는, 스트림 API가 지원하는 연산을 이용해서 filtering, slicing, mapping, finding, matching, and reducing 등 다양한 데이터 처리 질의를 표현을 보연준다. 숫자 스트림, 파일과 배열 등 다양한 소스로 스트림을 만드는 방법과 무한 스트림 등 스트림의 특수한 경우도 살펴볼 것이다.

5.1 필터링

스트림의 요소를 선택하는 방법, 즉 Predicate 필터링 방법과 고유 요소만 필터링하는 방법을 보자.

5.1.1 Predicate로 필터링

filter() : Predicate를 인수로 받아 해당하는 모든 요소를 포함하는 스트림을 반환 (참,거짓)

5.1.3 고유 요소 필터링

distinct() : 중복 제거

5.2 스트림 슬라이싱

요소 선택 또는 스킵하는 방법을 보자.

5.2.1 Predicate를 이용한 슬라이싱

슬라이싱 : 자원을 아끼려 중간에 그만 두는 것

takeWhile(), dropWhile() (자바 9 부터)

320 칼로리 이하의 요리를 선택해보자.

// 이미 정렬되어 있음
List<Dish> specialMenu = Arrays.asList(
    new Dish("seasonal fruit", true, 120, Dish.Type.OTHER),
    new Dish("prawns", false, 300, Dish.Type.FISH),
    new Dish("rice", true, 350, Dish.Type.OTHER),
    new Dish("chicken", false, 400, Dish.Type.MEAT),
    new Dish("french fries", true, 530, Dish.Type.OTHER)
);

앞서 배운 filter 사용할 경우. 모든 요소를 반복 한다.

이미 정렬 되었기에, 320칼로리 이상 요리가 나올때 반복작업 중단 필요.

takeWhile() : 무한 스트림을 포함한 모든 스트림에 Predicate를 적용해 슬라이스를 할 수 있다.

List<Dish> slicedMenu1
    = specialMenu.stream()
        .takeWhile(dish -> dish.getCalories() < 320) // 중단 사용
        .collect(toList());

그럼 320 칼로리보다 큰 요소 탐색은?

dropWhile()

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

5.2.2 스트림 축소

limit()

List<Dish> dishes = specialMenu
    .stream()
    .filter(dish -> dish.getCalories() > 300)
    .limit(3) // 반환 개수 제한
    .collect(toList());

(filter에서 요소 하나가 걸러진 후 limit에 채워지고 filter의 한요소가 실행, n 반복)

5.2.3 요소 건너뛰기

skip()

List<Dish> dishes = menu.stream()
    .filter(d -> d.getCalories() > 300)
    .skip(2) // n 번 건너뛰고 시작
    .collect(toList());

퀴즈

How would you use streams to filter the first two meat dishes?

// 이미 정렬되어 있음
List<Dish> specialMenu = Arrays.asList(
    new Dish("seasonal fruit", true, 120, Dish.Type.OTHER),
    new Dish("prawns", false, 300, Dish.Type.FISH),
    new Dish("rice", true, 350, Dish.Type.OTHER),
    new Dish("chicken", false, 400, Dish.Type.MEAT),
    new Dish("french fries", true, 530, Dish.Type.OTHER)
);

정답

List<Dish> dishes =
 menu.stream()
 .filter(dish -> dish.getType() == Dish.Type.MEAT)
 .limit(2)
 .collect(toList());

5.3 매핑

map, flatMap : 특정 데이터를 선택하는 기능

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

map : 함수로 인수를 받는다. 함수는 각 요소에 적용되고 결과는 새로운 요소로 매핑. ("modify"보다 "trasforming "에 가깝다, trasforming = mapping)

// getName은 문자열 반환하므로 출력스트림은 Stream<String> 형식을 같는다.
List<String> dishNames = menu.stream()
    .map(Dish::getName) // 새로운 요소로 매핑
    .collect(toList()); 

List<String> words = Arrays.asList("Modern", "Java", "In", "Action");
List<Integer> wordLengths = words.stream()
 .map(String::length)
 .collect(toList());

체이닝도 가능하다.

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

5.3.2 스트림 평면화

아래 두 코드의 문제는 무엇일까?

목표 결과: ["H," "e," "l," "o," "W," "r," "d"]

String[] words = {"Hello","World"};

// 시도 1
words.stream()
    .map(word -> word.split(""))
    .distinct()
    .collect(toList());
// 결과:  ["H," "e," "l," "o," "W," "o," "r," "d"]. o가 두번..

// 시도 2
words.stream()
    .map(word -> word.split(""))
    .map(Arrays::stream)
    .distinct()
    .collect(toList());

책에 그림은 보면 쉽게 이해 가능.

1 문제, map메서드가 Stream을 형식을 반환. distinct에서 배열별로 중복 제거. 2 문제, List> 스트림 리스트가 만들어 진다.

이제 문제를 해결해보자.

flatMap

List<String> uniqueCharacters =
    words.stream()
    .map(word -> word.split(""))
    .flatMap(Arrays::stream) // 생성된 스트림을 하나의 스트림으로 평면화
    .distinct()
    .collect(toList());

flatMap은 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다.

퀴즈

퀴즈 1

Given a list of numbers, how would you return a list of the square of each number? For example, given [1, 2, 3, 4, 5] you should return [1, 4, 9, 16, 25].

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> squares = numbers.Stream()
    .map(num->num*num)
    .collect(toList())

퀴즈 2

Given two lists of numbers, how would you return all pairs of numbers? For example, given a list [1, 2, 3] and a list [3, 4] you should return [(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]. For simplicity, you can represent a pair as an array with two elements

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(3, 4);

List<int[]> pairs =
    numbers1.stream()
    .flatMap(i -> numbers2.stream()
             .map(j -> new int[]{i, j})
            )
    .collect(toList());

퀴즈 3

How would you extend the previous example to return only pairs whose sum is divisible by 3?

List<int[]> pairs =
    numbers1.stream()
    .flatMap(i ->
             numbers2.stream()
             .filter(j -> (i + j) % 3 == 0)
             .map(j -> new int[]{i, j})
            )
    .collect(toList());

13페이지부터 (167페이지) 다시

5.4

검색과 매칭

5.5

리듀싱

5.6

5.7

5.8

스트림 만들기

5.9 마치며