#11 Stream API

스트림을 사용하는데에는 기본적으로 1. Stream 생성 2. 중개연산 3. 최종연산(Terminal Op) 으로 나눌 수 있다.

 

# Stream API 특징

• Java의 모든 Collection은 내부에 stream()이라는 기본 메서드가 존재한다. 컬렉션이 아닌 값들은 Stream.of(~) 메서드로 생성할 수 있다.
• 중개연산 메서드는 최종연산이 나오기 전까지 실행되지 않는다. 또한 중개연산 메서드는 Stream을 반환하므로 Stream.funcA(~).funcB(~).funcC(~) 같이 메소드 체이닝이 가능하다.
• 한번 사용한 스트림은 재사용 할 수 없다. 즉 최종연산 이후 stream API 연산을 다시 할 수 없다.
• Stream API는 함수형 인터페이스와 함께 사용하기 좋게 설계되어있다.
  

  

  물론 필요에 따라 (value) -> {~} 으로 직접 구현해도 된다.

---

# 0. Boxing 이란

Wrapper Class들을 이용해서 기본타입들(Primitive Type)를 객체(Reference Type)으로 변환하는 것을 박싱(Boxing), 반대로 기본 타입으로 되돌리는 것을 언박싱(unBoxing)이라 한다. 참고로 자바 초기화 문법에서 오토박싱을 지원해준다.

Integer num = new Integer(17); // 박싱
int n = num.intValue();        // 언박싱

// 이렇게 사용해도 내부적으로 박싱/언박싱이 이루어진다.
Character ch = 'X'; // Character ch = new Character('X'); : 오토박싱
char c = ch;        // char c = ch.charValue();           : 오토언박싱

• 박싱은 기본타입을 객체로 만들어 여러가지 추가기능을 넣을 수 있지만, 그만큼 기본타입만 사용했을 때 보다 비용이 추가적으로 발생함을 유의해야 한다.
• Stream에서도 마찬기지로 Stream<Integer>와 같이 기본형을 박싱하여 사용하는 것은 성능을 크게 저하시키기에 기본형 특화 스트림 (IntStream, LongStream, DoubleStream 등)을 따로 제공해준다.
• IntStream과 같은 기본형 스트림의 .boxed() 메서드를 이용하여 박싱할 수 있다.

// 기본형(Primitive Type) 스트림을 박싱하는 방법.
Stream<Integer> boxedIntStream = IntStream.range(1, 5).boxed();

• 반대로 Stream을 기본형 스트림으로 바꾸고자 한다면 .mapToInt() .mapToLong() 같은 메서드를 사용하면 된다.

// .mapToType() 메서드를 이용하여 기본형 스트림으로 변환 가능하다.
// 이 메서드는 타입을 변경하는 것 이외에는 .map()과 동일한 기능을 한다.
Stream.of(1.0, 2.0, 3.0) // Stream<Double> 생성
.mapToInt(Double::intValue) // IntStream으로 변환

// .mapToObj() 를 이용하면 .boxed()처럼 IntStream -> Stream<Intger> 로 변환도 가능하다.
IntStream.range(1, 4).mapToObj(i -> "a" + i)

 

---

# 1. 스트림 생성하기

# 배열 (Array) Stream

배열은 내부에 stream 메서드가 없다. 보통 Arrays 안에 있는 Arrays.stream() 메서드를 사용한다.

String[] arr = new String[]{"a", "b", "c"};

Stream<String> stream = Arrays.stream(arr);

Stream<String> streamOfArrayPart = 
  Arrays.stream(arr, 1, 3); // 1~2 요소 [b, c]

 

---

# Collection Stream

컬렉션의 경우 내부에 Stream 메서드가 존재하므로, 손쉽게 사용할 수 있다.

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
Stream<String> parallelStream = list.parallelStream(); // 병렬 처리 스트림

 

---

# Empty Stream (null 값 대체)

빈 스트림이 필요할 경우 Stream.empty()를 이용하여 빈 스트림을 생성할 수도 있다. 이는 null 값 사용을 대신해준다.

// 컬렉션에 값이 비었다고 스트림 연산의 값을 null로 주는 건 오류를 발생 시킬 수 있다.
list.isEmpty() ? Stream.empty() : list.stream();

 

---

# 기본 타입형 Stream

기본타입의 연속된 값들을 Stream으로 만들 땐, 각각의 Stream 객체안에있는 range를 이용해서 만들 수 있다.

IntStream intStream = IntStream.range(1, 5); // [1, 2, 3, 4]
LongStream longStream = LongStream.rangeClosed(1, 5); // [1, 2, 3, 4, 5]

// Random한 수가 필요하다면
DoubleStream doubles = new Random().doubles(3); // 난수 3개 생성

물론 특정 값이 필요하다면 Stream.of() 를 이용해서 만드는 방법도 있다.

public static void main(String args[]) {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5); // 1,2,3,4,5 생성
    
    List<Integer> numbers = stream.map(x -> x + 1)
            .filter(x -> x % 2 == 0)
            .collect(Collectors.toList());

    numbers.stream().forEach(System.out::println); // 2, 4, 6
}

 

---

# 문자 Stream

보통은 String 자체를 스트림에 넣어 사용하지만, 문자열 자체를 문자(char)로 나누어 스트림을 만들고 싶다면 str.chars()를 이용하면 된다.

// Char 값을 IntStream에 넣게되면 해당 문자의 코드표로 전환된다.
IntStream charsStream = 
  "Stream".chars(); // [83, 116, 114, 101, 97, 109]
  
// 보통은 굳이 Char로 변환하지않고, String 값 자체를 이용합니다.
Stream<String> stringStream = 
Pattern.compile("- ").splitAsStream("Eric- Elena- Java"); // ["Eric", "Elena", "Java"]

 

---

# 스트림 연결하기 (Stream.concat)

여러개로 나누어져있는 스트림을 Stream.concat 으로 연결 할 수 있습니다.

Stream<String> stream1 = Stream.of("Java", "Scala", "Groovy");
Stream<String> stream2 = Stream.of("Python", "Go", "Swift");
Stream<String> concat = Stream.concat(stream1, stream2);
// [Java, Scala, Groovy, Python, Go, Swift]

 

---

# Stream.builder (스트림에 직접 값 추가)

다른 값을 연결하거나 변환하지않고 직접 해당 Stream에 값을 추가하고 싶다면 Stream.builder()를 사용하면 된다. 해당 스트림에서 builder() 메서드를 호출한 후, 원하는 작업을 하고 마지막에 .build() 해주면 완료된다.

Stream<String> builderStream = 
  Stream.<String>builder()
    .add("Eric").add("Elena").add("Java")
    .build(); // [Eric, Elena, Java]

 

 

---

# Stream.generate (함수로 스트림 값 생성)

Stream.generate(~)를 이용하면 함수를 이용해 값을 생성해 낼 수 있다. 물론 그냥 사용하면 개수가 무한인(infinite) 스트림이 만들어지기에 .limit(n)나 .skip(n)을 이용해 개수를 제한하여 스트림을 생성할 수 있다.

• .limit(n) 처음부터 n개 까지의 값만 사용한다.
• .skip(n) 값을 앞에서부터 n개 뛰어넘고 나머지 값을 사용한다.

// java.util.function에 있는 Supplier를 이용해도 된다. 메서드 원형도 그러함. 
public static<T> Stream<T> generate(Supplier<T> s) { ... }


Stream<String> generatedStream =
        Stream.generate(() -> "A").limit(4); // ["A", "A", "A", "A"]

public static void main(String args[]) {
    Supplier<String> supplyHi = () -> "Hi";

    Stream<String> generatedStream =
            Stream.generate(supplyHi).limit(4);

    String str = generatedStream.collect(Collectors.joining(" "));
    System.out.println(str); // Hi Hi Hi Hi
}

 

---

# Stream.iterate()

generate와 비슷한데, 다른 점은 초기값을 주고 메서드를 이터레이터처럼 사용한다.

Stream<Integer> iteratedStream = 
  Stream.iterate(30, n -> n + 2).limit(5); // [30, 32, 34, 36, 38]

 

---

# 파일 Stream

잘 사용하지는 않지만, 파일 객체를 문자열 스트림으로 사용 할 수 있다.

// 파일을 String 스트림으로 변경
Stream<String> lineStream = 
  Files.lines(Paths.get("file.txt"), 
              Charset.forName("UTF-8"));

 

---

# 병렬 스트림

Stream 대신 parallelStream을 이용하여 간단하게 병렬 스트림을 만들 수 있다. parallelStream은 쓰레드를 처리하기 위해 내부적으로 Fork/Join framework를 사용한다.

// 병렬 스트림 생성
Stream<Product> parallelStream = productList.parallelStream();

// 병렬 여부 확인
boolean isParallel = parallelStream.isParallel();

// 예제
public static void main(String[] args) {		
    List<String> list = Arrays.asList("AAA","BBB","CCC","DDD","EEE");
		 
    //순차처리
    Stream<String> stream = list.stream();
    stream.forEach(System.out::println);
    
    //병렬처리
    Stream<String> parallelStream = list.parallelStream();
    parallelStream.forEach(System.out::println);
}

 

---

# 2. 스트림 가공하기 (중개연산)

# filter

현재 요소를 조건에 따라 걸러내는 작업을 해준다.

Stream<T> filter(Predicate<? super T> predicate);

List<String> names = Arrays.asList("Eric", "Elena", "Java");
Stream<String> stream = 
  names.stream()
  .filter(name -> name.contains("a"));
// 이름에 a가 포함되는 단어만 남게됨. ex) [Elena, Java]

 

 

---

# map

각각의 요소를 input으로 받아서 새로운 값으로 변환함. 이러한 작업을 Mapping이라고 부르기도 한다.

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

List<String> names = Arrays.asList("Eric", "Elena", "Java");
Stream<String> stream = 
  names.stream()
  .map(String::toUpperCase); // [ERIC, ELENA, JAVA]

// 이런 식으로 객체 안의 특정 필드를 꺼내올 수도 있음.
Stream<Integer> stream = 
  productList.stream()
  .map(Product::getAmount);
// [23, 14, 13, 23, 13]

 

---

# flatMap

쉽게 설명하면, 요소가 중첩되어있으면 한단계 풀어주어 쉽게 사용하게 만들어주는 map이다.

배열의 요소가 아닌 배열 자체를 입력값으로 받는경우 [ [1,2,3], [4,5,6] ] 처럼 중첩되는 스트림이 만들어진다.

이를 스트림으로 작업하게 되면 [1, 2, 3, 4, 5, 6]이 아니라 [1,2,3] [4,5,6] 으로 스트림 요소가 결정되어 스트림 반환값이 중첩되어 다음 작업을 하기 까다로워지는데, flatMap을 사용하면 반환값이 중첩되어있으면 중첩을 1단계 제거해준다.

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

Stream<String[]> strStream = Stream.of(
    new String[] {"a", "b", "c"}, 
    new String[] {"d", "e", "f"}
    );
    

// 위의 값을 그냥 map을 사용하면 2중 Stream이 반환됨 
// 요소가 총 2개임. ["a", "b", "c"], ["d", "e", "f"]
// Arrays.stream( ["a", "b", "c"] )...
Stream<Stream<String>> stream = strStream.map(Arrays::stream);

// flatMap을 사용하면 1중 Stream으로 차원을 낮출 수 있음
// 요소가 중첩되어있다면 한단계 풀어줌. 요소가 총 6개임 ["a","b","c","d","e","f"] 
// Arrays.stream( "a" )...
Stream<String> stream = strStream.flatMap(Arrays::stream);

Map vs FlatMap 상세설명

Stream<String[]> 처럼 입력값 자체가 리스트로 주어질 경우

Map => 요소 2개 [1,2], [1,1] => [ [1,2], [1,1] ] 반환

FlatMap => 요소가 중첩되어있으면 한번 제거 후 사용, 요소 4개 [ [1, 2], [1, 1] ] => [1,2,1,1] 반환

 

* 참고로 Stream<String[]>을 해주었다해서 배열안에 있는 요소까지 스트림화 된 것은 아니다. 주소값이 스트림화 된 것이므로 안에 들어있는 요소들은 원본 그대로이기에 안에 있는 값들을 Arrays.Stream으로 복사해주어야한다.

Stream<String[]>은 가르키는 주소값을 복사한것이다.

 

내부의 요소들에게 Arrays.Stream( 요소 ) 를 통해 이렇게 바꾸어주어야한다.

---

예제

String[] arrayOfWords = {"Hello", "World"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);

streamOfWords.map(s->s.split("")) // 문자열을 Array로 바꿈.
    .map(Arrays::stream) // 하나의 배열 [H,e,l,l,o]을 Stream<String[]> 으로 바꿈. 
    .distinct() // 중복을 제거하고 싶었으나 배열이 중첩되어 동작하지 않는 코드.
    .collect(Collectors.toList());
    // [ ["H","e","l","l","o"], ["W","o","r","l","d"] ]

결과물 : [ [H,e,l,l,o], [W,o,r,l,d] ]

1. map(s->s.split)에 의해 "HELLO"가 [H,E,L,L,O]로 분리된다.
2. 현재 스트림은 중첩되어있으므로 distinct()는 아무런 역할을 하지 않는다.
3. 즉 결과물도 그대로 중첩된 [ [H,E,L,L,O], [W,O,R,L,D] ] 배열이 리턴된다.

 

이를 FlatMap을 이용해주면 쉽게 해결 할 수 있다.

String[] arrayOfWords = {"Hello", "World"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);

streamOfWords.map(s->s.split("")) // 문자열을 Array로 바꿈
    .flatMap(Arrays::stream) //각각의 요소가 중첩이 제거되고, Stream<String>이 적용됨
    .distinct() // 중복이 제거됨
    .collect(Collectors.toList());
    // ["H","e","l","o","W","r","d"]

1. map(s->s.split(""))의 결과로 나온 이중 배열 [ [H,E,L,L,O] [W,O,R,L,D] ]를 FlatMap에 넘긴다.

2. FlatMap은 [H,E,L,L,O] , [W,O,R,L,D]로 배열 2개를 입력으로 받는다. FlatMap은 요소 마다 중첩을 제거하여 H,E,L,L,O,W,O,R,L,D를 입력으로 받고 이를 Arrays.stream(~)을 이용하여 각각의 단어를 Stream<String>으로 변환한다.

 

당연한거지만, flatMap도 map과 동일하게 응용가능하다.

// students 는 Student 객체가 들어가있는 list이다.
students.stream() 
  .flatMapToInt(student -> // 학생객체를 [국어점수,영어점수,수학점수] 로 만든다.
                IntStream.of(student.getKor(), 
                             student.getEng(), 
                             student.getMath()))
// 그냥 map을 사용하면 students stream의 한 요소에 "[국어,영어,수학]" 이렇게 저장된다.
// flatMap을 이용하여 "국어,영어,수학" 으로 중첩되어있는 배열을 풀어주어야 average()가 가능하다.
  .average().ifPresent(avg -> 
                       System.out.println(Math.round(avg * 10)/10.0)); // 각 학생의 평균점수.

 

---

# sorted

값을 오름차순으로 정렬한다. 필요하다면 sorted(~)에 비교 함수(Comparator)를 줘 원하는 기준으로 정렬할 수 있다.

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

// 오름차순 정렬
intList.stream().sorted()

// 내림차순 정렬 
intList.stream().sorted(Comparator.reverseOrder())

// 해당 객체가 Comparable 인터페이스를 구현하지 않는다면 이렇게 내림차순 구현가능.
strList.stream().sorted(Comparator.comparing(String::length).reversed())

// 메서드 레퍼런스 사용 (Comparable 인터페이스를 구현하고 있는 객체만 가능)
intList.stream().sorted(Integer::compareTo)

// 람다 사용 (Comparable 인터페이스를 구현하고 있는 객체만 가능)
intList.stream().sorted((a, b) -> a.compareTo(b))

// 익명 클래스로 Comparator 직접 구현
// compareTo()는 int형을 반환한다. a 보다 (크다 1), (같다 0), (작다 -1)
intList.stream().sorted(new Comparator<Integer>() {
    @Override
    public int compare(Integer a, Integer b) {
        return a.compareTo(b);
    }
})

List<String> lang = 
  Arrays.asList("Java", "Scala", "Groovy", "Python", "Go", "Swift");

lang.stream()
  .sorted()
  .collect(Collectors.toList());
// [Go, Groovy, Java, Python, Scala, Swift]

lang.stream()
  .sorted(Comparator.reverseOrder())
  .collect(Collectors.toList());
// [Swift, Scala, Python, Java, Groovy, Go]

 

---

# 이터레이터 (peek)

map은 스트림 요소를 직접 수정한다. 만약 수정이 필요없고 읽기만 한다면 peek을 사용하면 된다.

peek는 Stream을 반환하는데, 만약 출력할 값이 없어서 끝내고 싶다면 forEach (map과 동일) 사용하면 된다. 

Stream<T> peek(Consumer<? super T> action);

int sum = IntStream.of(1, 3, 5, 7, 9)
  .peek(System.out::println) // 스트림 요소들을 수정할 수 없다. 읽기만 한다.
  .sum();

 

---

# Optional API (null 값 처리, boxing)

2021.07.12 - [Backend/Java] - #12. Optional API (*Null값 처리)

---

#3. 스트림 결과 만들기 (최종연산)

# 단일 값 (Calculating)

스트림의 요소들을 하나의 값으로 만든다. .count() .sum() .min() .max() 등 기본형 타입으로 결과를 만든다.

long count = IntStream.of(1, 3, 5, 7, 9).count();
long sum = LongStream.of(1, 3, 5, 7, 9).sum();

count나 sum은 요소가 없으면 0을 반환하면 되지만, min, max, average처럼 결과가 없는 경우 Null값 처리를 위해 Optional 객체를 사용한다.

OptionalInt min = IntStream.of(1, 3, 5, 7, 9).min();
OptionalInt max = IntStream.of(1, 3, 5, 7, 9).max();

DoubleStream.of(1.1, 2.2, 3.3, 4.4, 5.5)
  .average()
  .ifPresent(System.out::println);

---

# Reduction (reduce)

직접 연산을 구현하고 싶다면, reduce를 이용하는 방법도 있다.

.reduce(초깃값, 함수, Combiner)이다. 참고로 combiner는 병렬 스트림을 하나로 합치는 reduce 연산이다.

// 인자 1개 (accumulator) 초기값 없음. (첫번째값=초기값)
Optional<T> reduce(BinaryOperator<T> accumulator);

// 인자 2개 (identity), 초기값 있음.
T reduce(T identity, BinaryOperator<T> accumulator);

// 3개 (combiner), 마지막 값으로  병렬 스트림으로 나눠 결과를 합치는 로직을 적는다.
<U> U reduce(U identity, 
  BiFunction<U, ? super T, U> accumulator,
  BinaryOperator<U> combiner);

// 인자가 하나인 경우 (함수)
OptionalInt reduced = 
  IntStream.range(1, 4) // [1, 2, 3]
  .reduce((a, b) -> Integer.sum(a, b)); // 람다식으로 표현
  
// 인자가 2개인 경우 (초깃값, 함수)
int reducedTwoParams = 
  IntStream.range(1, 4) // [1, 2, 3]
  .reduce(10, Integer::sum); // 메소드 레퍼런스로 표현
  
// 인자가 3개인 경우 (초깃값, 함수, Combiner)
Integer reducedParallel = Arrays.asList(1, 2, 3)
  .parallelStream() // 단일 Stream의 경우 Combiner는 사용되지 않는다.
  .reduce(10, Integer::sum,
          (result1, result2) -> { // Combiner. 각각의 스레드 결과를 합치는 reducer
            System.out.println("combiner was called");
            return result1 + result2;
          });

// 마지막 병렬 스트림 실행결과. 스레드가 여러개라면 앞에서부터 순차적으로 실행된다.
combiner was called // result1 + result2
combiner was called // [앞에서 계산한 result] + result2
36

---

# Collect (컬렉션 반환)

원하는데로 가공이 끝난 Stream을 하나의 값이 아니라 Collection으로 바꾸어주는 최종연산(Terminal) 메서드이다. 해당 메서드는 Collectors 클래스에 모여있다.

Stream.of(1, 3, 3, 5, 5)
      .filter(i -> i > 2)
      .map(i -> i * 2)
      .map(i -> "#" + i)
      .collect(joining("-", "<=", "=>")) // "<=#6 - #6 - #10 - #10=>"

 Collectors.joining(구분자, prefix, postfix)  : stream의 원소들을 하나의 String으로 concat 한다.

 Collectors.toList()  : stream의 원소들을 List에 담아서 return 한다

 Collectors.toSet()  : stream의 원소들을 set에 담아서 return 한다. ( * distinct() 라는 중개연산자를 사용하면, toList를 통해서도 순서가 보장된 set을 구현 할 수 도 있다.)

---

# 기본 자료형 컬렉션 Collectors.method()

.sum(), .average() 은 값을 반환하는 반면, collect(Collectors.메서드)는 컬렉션을 반환받을 수 있다.

// 스트림을 통해 int 요소들을 받아 전체 평균을 Double 컬렉션으로 반환함.
Double averageAmount = 
 productList.stream()
  .collect(Collectors.averagingInt(Product::getAmount));

// 스트림을 통해 int 요소들을 받아 전체 합을 Integer 컬렉션으로 반환함.
Integer summingAmount = 
 productList.stream()
  .collect(Collectors.summingInt(Product::getAmount));
 
 // SummaryStatistics 객체를 이용해 여러 통계 값을 한번에 얻을 수 있다.
 // IntSummaryStatistics {count=5, sum=86, min=13, average=17.200000, max=23}
 IntSummaryStatistics statistics = 
 productList.stream()
  .collect(Collectors.summarizingInt(Product::getAmount));
  
 statistics.getCount()
 statistics.getSum()
 statistics.getAverage()
 statistics.getMin()
 statistics.getMax()

// 물론 기본형 스트림으로 전환해서 사용하는 방법도 있다.
Integer summingAmount = 
  productList.stream()
  .mapToInt(Product::getAmount) // 기본형 int 스트림으로 전환
  .sum(); // sum 사용가능

 

---

# Collectors.groupingBy()

특정 조건으로 요소들을 그룹화 하는 방법도 있다. 결과는 Map<Integer, List<>> 와 같은 형태의 컬렉션으로 반환된다.

Map<Integer, List<Product>> collectorMapOfLists =
 productList.stream()
  .collect(Collectors.groupingBy(Product::getAmount));
 
 // Product로 이루어진 리스트를 amount(int)로 groupingBy 한 결과
 // Map에 key는 int형, value는 리스트로 반환된다. 리스트 안에는 Product 객체가 있다.
     23=[Product{amount=23, name='potatoes'}, Product{amount=23, name='bread'}], 
     
     13=[Product{amount=13, name='lemon'}, Product{amount=13, name='sugar'}], 
     
     14=[Product{amount=14, name='orange'}]
 }

 

# Colletors.partitioningBy()

grounpingBy와 거의 비슷한데, 함수 값이 아닌 조건 (Predicate)을 key값으로 이용하여 리스트를 2개로 나눈다.

Map<Boolean, List<Product>> mapPartitioned = 
  productList.stream()
  .collect(Collectors.partitioningBy(el -> el.getAmount() > 15));
  
{ // 결과물
  false=[ Product{amount=14, name='orange'}, 
          Product{amount=13, name='lemon'}, 
          Product{amount=13, name='sugar'} ], 
          
   true=[Product{amount=23, name='potato'}, 
          Product{amount=23, name='bread'} ]
}

---

# Collector.of()

원하는 Collector가 없다면 .of()로 만들고 Collector 객체에 담아 사용 할 수 있습니다. 이 메서드는 .reduce()와 동일하게 동작합니다.

public static<T, R> Collector<T, R, R> of(
  Supplier<R> supplier, // new collector 생성
  BiConsumer<R, T> accumulator, // 두 값을 가지고 계산
  BinaryOperator<R> combiner, // 계산한 결과를 수집하는 함수.
  Characteristics... characteristics) { ... }

Collector<Product, ?, LinkedList<Product>> toLinkedList = 
  Collector.of(LinkedList::new, //초깃값 Collector 
               LinkedList::add, //함수
               (first, second) -> { // Combiner, 여기에서는 결과를 만드는데 사용한다.
                 first.addAll(second);
                 return first;
               });
               
// 이렇게 만들어진 Collector 함수는 아래와 같이 사용할 수 있다.
LinkedList<Product> linkedListOfPersons = 
  productList.stream()
  .collect(toLinkedList); // 내가 만든 Collector 함수, toLinkedList

---

# Match (조건 확인, boolean 반환)

Predicate 를 이용하여 해당 조건에 만족하는 요소가 있는지 확인한 후 boolean 값을 리턴한다.

만약 조건에 따라 값을 변경하고 싶다면 중간연산인 filter를 이용하자.

• 하나라도 조건을 만족하는 요소가 있는지(.anyMatch)
• 모두 조건을 만족하는지(.allMatch)
• 모두 조건을 만족하지 않는지(.noneMatch)

boolean anyMatch(Predicate<? super T> predicate);
boolean allMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);

List<String> names = Arrays.asList("Eric", "Elena", "Java");

boolean anyMatch = names.stream()
  .anyMatch(name -> name.contains("a")); // true
  
boolean allMatch = names.stream() 
  .allMatch(name -> name.length() > 3); // true
  
boolean noneMatch = names.stream()
  .noneMatch(name -> name.endsWith("s")); // true

---

# forEach

자바의 for-Each 문이나 map()과 비슷하다. 다만 Stream을 반환하지않고 연산을 종료한다.

names.stream().forEach(System.out::println);