중간 연산자

1. filter()

정보

filter(Predicate<? super T> predicate)

• 반환값 : Stream<T>
• 기능 : 조건식에 해당하는 요소들만 필터링하여 새로운 스트림으로 만드는 기능.

예제 코드

• 인풋

  List<Member> members = new ArrayList<>();
  
  members.add(new Member(1L,"A"));
  members.add(new Member(2L,"B"));
  members.add(new Member(3L,"C"));
  members.add(new Member(4L,"D"));

• 중간 연산자

  List<Member> evenMembers = members.stream()
                                    .filter(member -> member.id % 2 == 0)
                                    .collect(Collectors.toList());

• 아웃풋

  evenMembers.forEach(member -> System.out.println(member.nickname));

• 결과
  

2. map()

정보

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

mapToDouble(ToDoubleFunction<? super T> mapper)
mapToInt(ToIntFunction<? super T> mapper)
mapToLong(ToLongFunction<? super T> mapper)

• 반환값 : Stream<T>
• 기능 : Stream의 요소를 일대일로 매핑하여 새로운 스트림으로 만드는 기능.

예제 코드

• 인풋

  List<Member> members = new ArrayList<>();
  
  members.add(new Member(1L,"A"));
  members.add(new Member(2L,"B"));
  members.add(new Member(3L,"C"));
  members.add(new Member(4L,"D"));

• 중간 연산자

  List<Member> newMembers = members.stream()
                        .map(member -> 
  							new Member(member.id, "new "+member.nickname)
  						)
  		                .collect(Collectors.toList());

• 아웃풋

  evenMembers.forEach(member -> System.out.println(member.nickname));

• 결과

혹은 식을 세울 수도 있습니다.

• 중간 연산자

  List<Member> newMembers = members.stream()
                                        .map(member -> {
                                            String name;
  										// 조건문 이용
                                            if(member.id % 2 == 1){
                                                name = "odd " + member.nickname;
                                            }else{
                                                name = "even " + member.nickname;
                                            }
  										// 반환값이 필요
                                            return new Member(member.id, name);
                                        })
                                        .collect(Collectors.toList());

• 결과

mapTo000()

• 반환값: 해당 타입의 Stream (mpaToDouble -> DoubleStream)
• 기능 : map과 동일하지만 반환값이 다름.

map()과 mapTo000()의 차이는 어떤 타입의 Stream으로 반환되는지의 차이입니다.

그럼 mapTo000()은 왜 쓰지?

다음과 같은 숫자 연산을 할때 Stream 객체라면 숫자 연산 함수가 없지만, DoubleStream등의 타입이라면 숫자 연산 함수가 있습니다.

3. flatMap()

정보

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

flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
flatMapToInt(Function<? super T,? extends IntStream> mapper)
flatMapToLong(Function<? super T,? extends LongStream> mapper)

• 반환값 : <R> Stream<R>
• 기능 : 중첩된 n차원의 Stream의 요소를 일대일로 매핑하여 1차원 혹은 낮은 단계 차원의새로운 스트림으로 만드는 기능.

예제 코드

• 인풋

  List<List<Member>> memberLists = new ArrayList<>();
  
  memberLists.add(Arrays.asList(new Member(1L,"A")));
  memberLists.add(Arrays.asList(new Member(2L,"B")));
  memberLists.add(Arrays.asList(new Member(3L,"C")));
  memberLists.add(Arrays.asList(new Member(4L,"D")));

• 중간 연산자

  List<Member> members=   memberLists.stream()
                                    .flatMap(membersL -> membersL.stream())
                                    .collect(Collectors.toList());
  
  //.flatMap(Collection::stream) 로 대체 가능

• 아웃풋

  System.out.println(members.size());

• 결과
  

flatMapTo000()

• 반환값: 해당 타입의 Stream (mpaToDouble -> DoubleStream)
• 기능 : mapTo000()와 비슷한 기능

flatMap()과 flatMapTo000()의 차이는 어떤 타입의 Stream으로 반환되는지의 차이입니다.

4. limit()

정보

limit(long maxSize)

• 반환값 : <R> Stream<R>
• 기능 : N개의 요소만을 뽑아 Stream으로 만드는 기능.
• 반대기능: skip()

예제 코드

• 인풋

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

• 중간 연산자

  List<Integer> newIntegers = integers.stream()
                                              .limit(2)
                                              .collect(Collectors.toList());

• 아웃풋

  newIntegers.forEach(integer -> System.out.println(integer));

• 결과
  

5. peek()

정보

peek(Consumer<? super T> action)

• 반환값 : <R> Stream<R>
• 기능 : 다른 중간 연산자를 사용하여 작업중 특정 작업을 사용하고 싶을때 사용. 주로 로깅 같은 작업에 사용됨

예제 코드

• 인풋

  List<Member> members = new ArrayList<>();
  
  members.add(new Member(1L,"A"));
  members.add(new Member(2L,"B"));
  members.add(new Member(3L,"C"));
  members.add(new Member(4L,"D"));

• 중간 연산자

   List<Member> evenMember = members.stream()
                                      .filter(member -> member.id % 2 == 0)
                                      .peek(member -> System.out.println(member.nickname))
                                      .collect(Collectors.toList());

• 결과
  

6. skip()

정보

skip(long n)

• 반환값 : <R> Stream<R>
• 기능 : Stream 중 앞에서 N개를 제외한 값을 새로운 Stream으로 생성
• 반대기능: limit()

예제 코드

• 인풋

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

• 중간 연산자

   List<Integer> newIntegers = integers.stream()
                                        .skip(2)
                                        .collect(Collectors.toList());
  

• 아웃풋

  newIntegers.forEach(integer -> System.out.println(integer));

• 결과
  

7. sorted()

정보

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

• 반환값 : <R> Stream<R>
• 기능 : Stream을 정렬된 Stream으로 만드는 기능.

예제 코드

• 인풋

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

• 중간 연산자

  List<Integer> newIntegers = integers.stream()
                                       .sorted()
                                       .collect(Collectors.toList());

• 아웃풋

  newIntegers.forEach(integer -> System.out.println(integer));

• 결과
  

정렬 기준 변경

Comparator에 따라 정렬 기준을 변경할 수 있습니다.

예제 코드

• 인풋
  위와 동일

• 중간 연산자

  List<Integer> newIntegers = integers.stream()
                                      .sorted(Comparator.reverseOrder())
                                      .collect(Collectors.toList());

• 아웃풋
  위와 동일

• 결과

Comparator은 공식문서에서 확인하실 수 있습니다.
java.util.Comparator