[윤성우 열혈자바] 30-2. 스트림의 중간 연산

맵핑(Mapping)에 대한 추가 정리

[Stream<T>의 map 시리즈 메소드들]    1:1 맵핑

<R> Stream<R> map(Function<T, R> mapper)

IntStream mapToInt(ToIntFunction<T> mapper)

LongStream mapToLong(ToLongFunction<T> mapper)

DoubleStream mapToDouble(ToDoubleFunction<T> mapper)

[Stream<T>의 flatMap 시리즈 메소드들]    1:* 맵핑

<R> Stream<R> flatMap(Function<T, Stream<R>> mapper)

IntStream flatMapToInt(Function<T, IntStream> mapper)

LongStream flatMapToLong(Function<T, LongStream> mapper)

DoubleStream flatMapToDouble(Function<T, DoubleStream> mapper)

flatMap에 전달할 람다식에서는 '스트림을 생성하고 이를 반환'

맵핑(Mapping)에 대한 추가 정리 : 예제 1

public static void main(String[] args) {

   Stream<String> ss1 = Stream.of("MY_AGE", "YOUR_LIFE");

 

   // 아래 람다식에서 스트림을 생성

   Stream<String> ss2 = ss1.flatMap(s -> Arrays.stream(s.split("_")));

   ss2.forEach(s -> System.out.print(s + "\t"));

   System.out.println();

}

MY    AGE    YOUR    LIFE

맵핑(Mapping)에 대한 추가 정리 : 예제 2

class ReportCard {

   private int kor; // 국어 점수

   private int eng; // 영어 점수

   private int math; // 수학 점수

 

   public ReportCard(int k, int e, int m) {

      kor = k;

      eng = e;

      math = m;

   }

   public int getKor() { return kor; }

   public int getEng() { return eng; }

   public int getMath() { return math; }

}

public static void main(String[] args) {

   ReportCard[] cards = {

      new ReportCard(70, 80, 90),

      new ReportCard(90, 80, 70),

      new ReportCard(80, 80, 80)

   };

 

   // ReportCard 인스턴스로 이뤄진 스트림 생성

   Stream<ReportCard> sr = Arrays.stream(cards);

 

   // 학생들의 점수 정보로 이뤄진 스트림 생성

   IntStream si = sr.flatMapToInt(

      r -> IntStream.of(r.getKor(), r.getEng(), r.getMath()));

   

   // 평균을 구하기 위한 최종 연산 average 진행

   double avg = si.average().getAsDouble();

   System.out.println("avg. " + avg);

}

OptionalDouble average()

   → 인터페이스 IntStream, LongStream, DoubleStream에 존재하는 메소드

정렬

Stream<T> sorted(Comparator<? super T> comparator)     // Stream<T>의 메소드

Stream<T> sorted() // Stream<T>의 메소드

IntStream sorted() // IntStream의 메소드

LongStream sorted() // LongStream의 메소드

DoubleStream sorted() // DoubleStream의 메소드

public static void main(String[] args) {

   Stream.of("Box", "Apple", "Robot")

         .sorted()

String 인스턴스는 Comparable<String> 인터페이스를 구현! 이를 기반으로 한 정렬

         .forEach(s -> System.out.print(s + '\t'));

   System.out.println();

   compareTo 메소드에 대한 람다식! 이를 기반으로 한 정렬

   Stream.of("Box", "Apple", "Rabbit")

         .sorted((s1, s2) -> s1.length() - s2.length())

         .forEach(s -> System.out.print(s + '\t'));

   System.out.println();

}

IntStream, LongStream, DoubleStream의 정렬

public static void main(String[] args) {

   IntStream.of(3, 9, 4, 2)

            .sorted()

            .forEach(d -> System.out.print(d + "\t"));

   System.out.println();

   

   DoubleStream.of(3.3, 6.2, 1.5, 8.3)

               .sorted()

               .forEach(d -> System.out.print(d + "\t"));

   System.out.println();

}

루핑(Looping)

대표적인 루핑 연산 forEach가 있다. 이는 ‘최종 연산’, 반면 다음 메소드들은 ‘중간 연산’으로 루핑 연산을 한다. 

Stream<T> peek(Consumer<? super T> action)          // Stream<T>의 메소드

IntStream peek(IntConsumer action)          // IntStream의 메소드

LongStream peek(LongConsumer action)         // LongStream의 메소드

DoubleStream peek(DoubleConsumer action)         // DoubleStream의 메소드

public static void main(String[] args) {

   // 최종 연산이 생략된 스트림의 파이프라인 - 출력되지 않음!!!!!!

   IntStream.of(1, 3, 5)

            .peek(d -> System.out.print(d + "\t"));

   System.out.println();

 

   // 최종 연산이 존재하는 스트림의 파이프라인

   IntStream.of(5, 3, 1)

            .peek(d -> System.out.print(d + "\t"))

            .sum();

   System.out.println();

}

5        3        1