자바의 정석 14장: 람다와 스트림(Lamda & Stream)

4️⃣

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

14-1 람다식(Lambda Expression )

14-2 람다식 작성하기

람다식 작성하기

주의사항

람다식 작성하기 퀴즈

14-4 람다식은 익명 함수? 익명 객체!

14-5 함수형 인터페이스

14-5 함수형 인터페이스 - example

14-6 함수형 인터페이스 타입의 매개변수, 반환타입

14-7 java.util.function 패키지

함수형 인터페이스

매개변수가 2개인 함수형 인터페이스

매개변수의 타입과 반환타입이 일치하는 함수형 인터페이스

14-8 Predicate의 결합

14-11 컬렉션 프레임웍과 함수형 인터페이스

14-13 메서드 참조(method reference)

14-14 생성자와 메서드 참조

14-15 스트림(Stream)

14-17~22 스트림 만들기

컬렉션

배열

임의의 수

스트림 만들기 - 특정 범위의 정수

스트림 만들기 - 람다식 iterate(), generate()

스트림 만들기 - 파일과 빈 스트림

14-23 스트림의 연산

14-26~29 스트림의 중간연산

스트림 자르기 - skip(), limit()

스트림의 요소 걸러내기 - filter(), distinct()

스트림 정렬하기 - sorted()

스트림의 요소 반환하기 - map()

스트림의 요소를 소비하지 않고 엿보기 - peek()

스트림의 스트림을 스트림으로 변환 - flatMap()

14-35 Optional<T>

14-36 Optional<T> 객체 생성하기

14-37 Optional<T> 객체의

14-38 OptionallInt, OptionalLong, OptionalDouble

14-40 스트림의 최종연산 - forEach()

14-41 스트림의 최종연산 - 조건 검사

14-42, 43 스트림의 최종연산 - reduce()

14-45 collector()와 Collectors

14-46 스트림을 컬렉션, 배열로 변환

14-47 스트림의 통계 - counting(), summingInt()

14-48 스트림을 리듀싱 - reducing()

14-53 스트림의 그룹화 - groupingBy()

14-1 람다식(Lambda Expression )

• 함수(메서드)를 간단한 ‘식(expression)’으로 표현하는 방법이다.

  int max(int a, int b) { // 메서드
  		return a > b ? a : b;
  }

  (a, b) -> a > b ? a : b // 람다식

• 익명 함수(이름이 없는 함수, anonymous)

  메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로 익명 함수라고 한다.

  int max(int a, int b) { // 메서드
  		return a > b ? a : b;
  }

  int max(int a, int b) -> { // 람다식
  		return a > b ? a : b;
  }

• 함수와 메서드의 차이
  • 근복적으로 동일. 함수는 일반적 용어, 메서드는 객체지향개념 용어
  • 함수는 클래스에 독립적, 메서드는 클래스에 종속적

Java는 원래 OOP언어임

JDK1.8부터 함수형 언어의 기능을 포함시킴

oop와 함수형언어라고 할 수는 있으나 함수형언어라고 하기에는 기능이 좀 약함 그냥 함수형 언어의 기능을 포함하고 있다 정도로 알고 있으면 됨

python, js → 둘다 oop, fp

정리 : 람다식은 함수(메서드)를 간단히 표현하려고 쓰는 것이다.

14-2 람다식 작성하기

람다식 작성하기

1. 메서드의 이름과 반환타입을 제거하고, 매개변수 선언부와 몸통{} 사이에 ‘→’를 추가한다.

   int max(int a, int b) { // 메서드
   		return a > b ? a : b;
   }

   int max(int a, int b) -> { // 람다식
   		return a > b ? a : b;
   }

2. 반환값이 있는 경우, 식이나 값만 적고 return문 생략 가능(끝에 ‘;’ 안 붙임)

   (int a, int b) -> {
   		return a > b ? a : b;
   }

   (int a, int b) -> a > b ? a : b

3. 매개변수의 타입이 추론 가능하면 생략가능(대부분의 경우 생략가능)

   (int a, int b) -> a > b ? a : b
   

   (a, b) -> a > b ? a : b

주의사항

1. 매개변수가 하나인 경우, 괄호() 생략가능(타입이 없을 때만)

   (a) -> a * a
   (int a) -> a * a

   a -> a * a     // OK
   int a -> a * a // 에러

2. 블록 안의 문장이 하나뿐일 때, 괄호{} 생략가능(끝에 ‘;’ 안 붙임)

   (int i) -> {
   		System.out.println(i);
   }

   (int i) -> System.out.println(i);

   단, 하나뿐인 문장이 return문이면 괄호{} 생략불가

   (int a, int b) -> { return a > b ? a : b; } // OK
   (int a, int b) -> return a > b ? a : b      // 에러

람다식 작성하기 퀴즈

메서드	람다식
int max(int a, int b) { return a > b ? a : b }	(a, b) → a > b ? a : b
int printVar(String name, int i) { System.out.println(name + “=” + i); }	(name, i) → System.out.println(name + “=” + i)
int square(int x) { return x * x; }	x → x * x
int roll() { return (int) (Math.random() * 6); }	() → (int) (Math.random() * 6)

14-4 람다식은 익명 함수? 익명 객체!

• 람다식은 익명 함수가 아니라 익명 객체이다.

  자바에서는 메서드만 존재할 수 없기 때문에(반드시 클래스 안에 속해야 함)

  (a, b) -> a > b ? a : b

  람다식 == 객체

  new Object() {
  		int max(int a, int b) {
  				return a > b ? a : b;
  		}
  }

  객체의 선언과 생성을 동시에 한 것이다.

• 람다식(익명 객체)을 다루기 위한 참조변수가 필요. 참조변수의 타입은?

  객체를 다루기 위해선 참조변수가 필요하다.

  Object obj = new Object() {
  		int max(int a, int b) {
  				return a > b ? a : b;
  		}
  }

  타입 obj = (a, b) -> a > b ? a : b; // 어떤 타입?

  int value = obj.max(3, 5); // 에러. Object 클래스에 max()가 없음

  Object라는 리모컨에서는 max()가 없다.

  그러면, 참조변수 f의 타입은 어떤 것이어야 할까? 참조형이니까 클래스 또는 인터페이스가 가능하다. 그리고 람다식과 동등한 메서드가 정의되어 있는 것이어야 한다. 그래야 참조변수로 익명 객체(람다식)의 메서드를 호출할 수 있기 때문이다.

• 14-0 예제

  package Test;
  
  class Main {
  	public static void main(String args[]) {
          // The target type of this expression must be a functional interfaceJava(553648781)
          // 람다식은 함수형 인터페이스로 다뤄야 한다는 에러 메시지가 나온다.
          // Object obj = (a, b) -> a > b ? a : b ;// 람다식. 익명객체 / 객체이기 때문에 참조변수로 다뤄야 한다.
  
          Object obj = new Object() {
              int max(int a, int b) {
                  return a > b ? a : b;
              }
          };
  
          int value = obj.max(3, 5); // Obejct type의 리모컨에는 max 메서드가 존재하지 않음 -> 함수형 인터페이스가 필요
   	} // main
  }

14-5 함수형 인터페이스

• 함수형 인터페이스 - 단 하나의 추상 메서드만 선언된 인터페이스

  람다식을 다루기 위한 인터페이스이다.

  // 함수형 인터페이스를 올바르게 작성했는지 확인해준다. / 필수는 아님, 붙이면 좋다는 것
  @FunctionalInterface 
  interface MyFunction {
  		public abstract int max(int a, int b);
  }

  MyFunction f = new MyFunction() { // 익명 클래스의 선언, 객체 생성 동시에
  		public int max(int a, int b) {
  				return a > b ? a : b;
  		}
  }

  new 조상이름(클래스 or 인터페이스) { // 멤버 }

  int value = f.max(3, 5); // OK. MyFunctioin에 max()가 있음

• 함수형 인터페이스 타입의 참조변수로 람다식을 참조할 수 있음.
  (단, 함수형 인터페이스의 메서드와 람다식의
  매개변수 개수와 반환타입이 일치해야 함)

  MyFunction f = (a, b) -> a > b > a : b;
  int value = f.max(3, 5); // 실제로는 람다식(익명 함수)이 호출됨

• 함수형 인터페이스 예제

  class Main {
  	public static void main(String args[]) {
          // MyFunction f = new MyFunction() {
          //     // int max(int a, int b) { // 오버라이딩 규칙 : 조상 메서드보다 좁근 접근제어자를 가질 수 없음.
          //     public int max(int a, int b) {
          //         return a > b ? a : b;
          //     }
          // };
          
          // 람다식(익명객체)을 다루기 위한 참조변수의 타입은 함수형 인터페이스로 한다.
          MyFunction f = (a, b) -> a > b ? a : b; // 람다식
          int value = f.max(3, 5); // 함수형 인터페이스
  
          System.out.println(value);
   	} // main
  }
  @FunctionalInterface // 함수형 인터페이스는 단 하나의 추상 메서드만 가져야 한다.
  interface MyFunction {
      int max(int a, int b); // 인터페이스의 모든 메서드는 public이면서 abstract다. 생략 가능.
      // public abstract int max(int a, int b);
      // public abstract int max(int a, int b); // FunctionalInterface 애너테이션을 붙였을 경우 함수형 인터페이스를 올바르게 작성했는지 확인해준다.
  
  }

  class Main {
  	public static void main(String args[]) {
          // 람다식(익명객체)을 다루기 위한 참조변수의 타입은 함수형 인터페이스로 한다.
          MyFunction f = (a, b) -> a > b ? a : b; // 람다식
          int value = f.max(3, 5); // 함수형 인터페이스
  
          System.out.println(value);
   	} // main
  }
  @FunctionalInterface // 함수형 인터페이스는 단 하나의 추상 메서드만 가져야 한다.
  interface MyFunction {
      int max(int a, int b); // 인터페이스의 모든 메서드는 public이면서 abstract다. 생략 가능.
  }

• 변환 과정(23.04.03. 추가)

  public class Main2 {
      public static void main(String[] args) {
          MyFunction f = new Test();
  
      }
  }
  
  interface MyFunction {
      int max(int a, int b);
  }
  
  class Test implements MyFunction {
      @Override
      public int max(int a, int b) {
          return a > b ? a : b;
      }
  }

  public class Main2 {
      public static void main(String[] args) {
          MyFunction f = new MyFunction() {
              @Override
              public int max(int a, int b) {
                  return a > b ? a : b;
              }
          };
      }
  }
  
  interface MyFunction {
      int max(int a, int b);
  }

  public class Main2 {
      public static void main(String[] args) {
          MyFunction f1 = (a, b) -> a > b ? a : b;
      }
  }
  
  interface MyFunction {
      int max(int a, int b);
  }

14-5 함수형 인터페이스 - example

• 익명 객체를 람다식으로 대체

  List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
  Collections.sort(list, new Comparator<String>() {
                              public int compare(String s1, String s2) {
                                  return s2.compareTo(s1);
                              }
                          });

  ⏬

  @FunctionalInterface // 함수형 인터페이스
  interface Comparator<T> {
  		int compare(T o1, T o2);
  }

  List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
  Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

• 변환 과정(23.04.03. 추가)

  public class Main2 {
      public static void main(String[] args) {
          List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
          Collections.sort(list, new SortTest());
      }
  }
  
  class SortTest implements Comparator<String> {
  
      @Override
      public int compare(String o1, String o2) {
          return o2.compareTo(o1); // 정렬기준 제공
      }
  }

  public class Main2 {
      public static void main(String[] args) {
          List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
          Collections.sort(list, new Comparator<String>() {
              @Override
              public int compare(String o1, String o2) {
                  return o2.compareTo(o1);
              }
          });
      }
  }

  public class Main2 {
      public static void main(String[] args) {
          List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
          Collections.sort(list, (o1, o2) -> o2.compareTo(o1));
      }
  }

14-6 함수형 인터페이스 타입의 매개변수, 반환타입

• 함수형 인터페이스 타입의 매개변수 → 람다식을 매개변수로 받겠다는 뜻이다.

  void aMethod(MyFunction f) { // 람다식을 매개변수로 받겠다는 뜻이다.
  		f.myMethod(); // MyFunction에 정의된 메서드 호출
  }

  MyFunction f = () -> System.out.println("test");
  aMethod(f);
  // aMethod(() -> System.out.println("test"));

  interface MyFunction {
  		void myMethod();
  }

• 함수형 인터페이스 타입의 반환타입 → 람다식을 반환하라는 뜻

  MyFunction myMethod() { // 람다식 반환
  		MyFunction f = () -> {}:
  		return f;
  }

  ⏩

  MyFunction myMethod() {
  		return () -> {};
  }

• 예제 14-1

  package Test;
  
  @FunctionalInterface
  interface MyFunction {
      void run(); // public abstract void run();
  }
  
  class Main {
      static void execute(MyFunction f) { // 매개변수의 타입이 MyFunction인 메서드
          f.run();
      }
  
      static MyFunction getMyFunction() { // 반환 타입이 MyFunction인 메서드
          return () -> System.out.println("f3.run()");
      }
  
  	public static void main(String args[]) {
          MyFunction f1 = () -> System.out.println("f1.run()");
  
          MyFunction f2 = new MyFunction() {
              public void run() { // public을 반드시 붙여야 함
                  System.out.println("f2.run()");
              }
          };
  
          MyFunction f3 = getMyFunction();
          // MyFunction f3 = () -> System.out.println("f3.run()"); // 위와 동일
  
          f1.run();
          f2.run();
          f3.run();
  
          System.out.println("======= execute =========");
  
          execute(f1);
          execute(f2);
          execute(f3);
          execute(() -> System.out.println("run()"));
   	} // main
  }

• 예제 14-1 변환과정(23.04.03. 월 추가)

  @FunctionalInterface
  interface MyFunction {
      void run(); // public abstract 생략
  }
  
  class Test implements MyFunction {
      @Override
      public void run() {
          System.out.println("f1.run");
      }
  }
  public class Main2 {
      public static void main(String[] args) {
          MyFunction f1 = new Test();
          f1.run();
  
      }
  }

  @FunctionalInterface
  interface MyFunction {
      void run(); // public abstract 생략
  }
  
  public class Main2 {
      public static void main(String[] args) {
          MyFunction f1 = new MyFunction() {
              @Override
              public void run() {
                  System.out.println("f1.run");
              }
          };
          f1.run();
      }
  }

  @FunctionalInterface
  interface MyFunction {
      void run(); // public abstract 생략
  }
  
  public class Main2 {
      public static void main(String[] args) {
          MyFunction f1 = () -> System.out.println("f1.run");
          f1.run();
      }
  }

14-7 java.util.function 패키지

• 자주 사용되는 다양한 함수형 인터페이스를 제공

함수형 인터페이스

함수형 인터페이스	메서드	설명
java.lang.Runnable	void run()	매개변수도 없고, 반환값도 없음
Supplier<T>	T get()	매개변수는 없고, 반환값만 있음
Consumer<T>	void accept(T t)	Supplier와 반대로 매개변수만 있고, 반환값이 없음
Function<T,R>	R apply(T t)	일반적인 함수, 하나의 매개변수를 받아서 결과를 반환
Predicate<T>	boolean test(T t)	조건식을 표현하는데 사용됨. 매개변수는 하나, 반환 타입은 boolean

Predicate<String> isEmptyStr = s -> s.length() == 0;
String s = "";

if (isEmptyStr.test(s)) { // if(s.length() == 0)
    System.out.println("This is an empty String.");
}

• Q. 아래의 빈 칸에 알맞은 함수형 인터페이스(java.util.function 패키지)를 적으시오.

  [   ①   ] f = () -> (int)(Math.random() * 100) + 1;
  [   ②   ] f = i -> System.out.print(i + ", ");
  [   ③   ] f = i -> i%2 == 0;
  [   ④   ] f = i -> i/10*10;

  • 정답

    Supplier<Interger> f = () -> (int)(Math.random() * 100) + 1; // input x output O
    Consumer<Integer> f = i -> System.out.print(i + ", ");
    Predicate<Integer> f = i -> i%2 == 0;
    Function<Integer, Integer> f = i -> i/10*10;

매개변수가 2개인 함수형 인터페이스

함수형 인터페이스	메서드	설명
BiConsumer<T,U>	void accept(T t, U u)	두개의 매개변수만 있고, 반환값이 없음
BiPredicate<T,U>	boolean test(T t, U u)	조건식을 표현하는데 사용됨. 매개변수는 둘, 반환값은 boolean
BiFunction<T,U,R>	R apply(T t, U u)	두 개의 매개변수를 받아서 하나의 결과를 반환

@FunctionalInterface
interface TriFunction<T,U,V,R> {
		R apply(T t, U u, V v);
}

매개변수의 타입과 반환타입이 일치하는 함수형 인터페이스

함수형 인터페이스	매서드	설명
UnaryOperator<T>	T apply(T t)	Function의 자손, Function과 달리 매개변수와 결과의 타입이 같다.
BinaryOperator<T>	T apply(T t, T t)	BiFunction의 자손, BiFunction과 달리 매개변수와 결과의 타입이 같다.

Unary : 단항

Binary : 이항

Operator : 연산자

• 예제 14-2

  package Test;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.function.*;
  
  class Main {
  	public static void main(String args[]) {
          Supplier<Integer> s = () -> (int)(Math.random() * 100) + 1;
          Consumer<Integer> c = i -> System.out.print(i + ", ");
          Predicate<Integer> p = i -> i % 2 == 0;
          Function<Integer, Integer> f = i -> i / 10 * 10;
  
          List<Integer> list = new ArrayList<>();
          makeRandomList(s, list); // 1~100 범위의 랜덤값을 List에 10개 넣는다.
          System.out.println(list);
          printEvenNum(p, c, list);
          List<Integer> newList = doSomething(f, list);
          System.out.println(newList);
          
   	} // main
  
      static <T> List<T> doSomething(Function<T, T> f, List<T> list) {
          List<T> newList = new ArrayList<T>(list.size());
  
          for (T i : list) {
              newList.add(f.apply(i));
          }
  
          return newList;
      }
  
       static <T> void printEvenNum(Predicate<T> p, Consumer<T> c, List<T> list) {
           System.out.print("[");
   
           for (T i : list) { // list에 있는 값을 하나씩 가져온다.
               if (p.test(i)) { // i의 값이 짝수면
                   c.accept(i); // i의 값을 출력한다.
               }
           }
           System.out.println("]");
       }
  
      static <T> void makeRandomList(Supplier<T> s, List<T> list) {
          for (int i = 0; i < 10; i++) {
              list.add(s.get()); // 1~100 범위의 랜덤값을 List에 10개 넣는다.
          }
      }
  }

14-8 Predicate의 결합

• and(), or(), negate()로 두 Predicate를 하나로 결합(default 메서드)

  인터페이스 = 추상메서드, static 메서드, default 메서드

  Predicate<Integer> p = i -> i < 100;
  Predicate<Integer> q = i -> i < 200;
  Predicate<Integer> r = i -> i % 2 == 0;

  Predicate<Integer> notP = p.negate(); // i >= 100
  Predicate<Integer> all = notP.and(q).or(r); // 100 <= i && i < 200 || i % 2 == 0
  Predicate<Integer> all2 = notP.and(q.or(r)); // 100 <= i && (i < 200 || i % 2 == 0)

  System.out.println(all.test(2));  // true
  System.out.println(all2.test(2)); // false

• 등가비교를 위한 Predicate의 작성에는 isEqual()를 사용(static메서드)

  Predicate<String> p = Predicate.isEqual(str1); // isEqual()는 static메서드
  Boolean result = p.test(str2); // str1과 str2가 같은지 비교한 결과를 반환
  
  ->
  boolean result = Predicate.isEqual(str1).test(str2);

• 예제 14-3

  // "abc" == "abc" -> true
  // new String("abc") == "abc" -> false(주소 비교이기 때문이다.)
  String str1 = new String("abc");
  String str2 = new String("abc");
  
  System.out.println(str1 == str2);
  
  // 이 결과값이 true라는 건 등가비교가 아니라 equals를 썼다는 걸 알 수 있다.
  boolean result = Predicate.isEqual(str1).test(str2);
  System.out.println(result);

  package chapter14;
  
  import java.util.function.Function;
  import java.util.function.Predicate;
  
  class Ex14_3 {
  	public static void main(String args[]) {
          Function<String, Integer> f = (s) -> Integer.parseInt(s, 16); // 16진수를 10진수로 변환
          Function<Integer, String> g = (i) -> Integer.toBinaryString(i);
          
          Function<String, String> h = f.andThen(g);    // f 적용하고 g를 적용해라
          Function<Integer, Integer> h2 = f.compose(g); // g 적용하고 f를 적용해라
  
          System.out.println(h.apply("FF")); // "FF" -> 255 -> "11111111"
          System.out.println(h2.apply(2));   // 2 -> "10" -> 16
  
          Function<String, String> f2 = x -> x;   // 항등 함수(identity function)
          System.out.println(f2.apply("AAA")); // AAA가 그대로 출력됨
  
          Predicate<Integer> p = i -> i < 100;
          Predicate<Integer> q = i -> i < 200;
          Predicate<Integer> r = i -> i % 2 == 0;
          Predicate<Integer> notP = p.negate(); // negate == not / i >= 100
  
          Predicate<Integer> all = notP.and(q.or(r)); // i >= 100 && (i < 200 || i % 2 == 0)
          System.out.println(notP.test(150)); // true
  
          String str1 = "abc";
          String str2 = "abc";
  
          // Predicate<String> p2 = Predicate.isEqual(str1); // isEqual의 반환타입은 Predicate(람다식 반환)
          // boolean result = p2.test(str2);
          System.out.println(Predicate.isEqual(str1).test(str2));
   	} // main
  }

14-11 컬렉션 프레임웍과 함수형 인터페이스

• 함수형 인터페이스를 사용하는 컬렉션 프레임워크의 디폴트 메서드(와일드 카드 생략)

  💡

  메서드 참조 == 클래스이름::메서드이름
  메서드 참조는 람다식을 더 간단히 한 것이다.
  

인터페이스	메서드	설명
Collection	boolean removeIf(Predicate<E> filter)	조건에 맞는 요소를 삭제
List	void replaceAll(UnaryOperator<E> operator	모든 요소를 변환하여 대체
Iterable	void forEach(Consumer<T> action)	모든 요소에 작업 action을 수행
Map	V compute(K key, BiFunction<K,V,V> f)	지정된 키의 값에 작업 f를 수행
“”	V computeIfAbsent(K key, Function<K,V> f)	키가 없으면, 작업 f 수행 후 추가
“”	V computeIfPresent(K key, BiFunction<K,V,V> f)	지정된 키가 있을 때, 작업 f 수행
“”	V merge(K key, V value, BiFunction<V,V,V> f)	모든 요소에 병합작업 f를 수행
“”	void forEach(BiConsumer<K,V> action)	모든 요소에 작업 action을 수행
“”	void replaceAll(BiFunction<K,V,V> f)	모든 요소에 치환작업 f를 수행

compute → map의 value를 변환

• 예제 14-4

  package Test;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  class Main {
  	public static void main(String args[]) {
          ArrayList<Integer> list = new ArrayList<>();
          for (int i = 0; i < 10; i++) {
              list.add(i);
          }
          // Iterator it = list.iterator();
          // while (it.hasNext()) {
          //     System.out.println(it.next());
          // }
          list.forEach(i -> System.out.print(i + ","));
          System.out.println();
          
          list.removeIf(x -> x % 2 == 0 || x % 3 == 0); // list에서 2또는 3의 배수를 제거한다.
          System.out.println(list);
  
          list.replaceAll(i -> i * 10); // list의 각 요소에 10을 곱한다.
          System.out.println(list);
  
          Map<String, String> map = new HashMap<>();
          map.put("1", "1");
          map.put("2", "2");
          map.put("3", "3");
          map.put("4", "4");
  
          // Iterator it = map.entrySet().iterator();
          // while (it.hasNext()) {
          //     System.out.println(it.next());
          // }
          // map의 모든 요소를 {k, v}의 형식으로 출력한다.
          map.forEach((k, v) -> System.out.printf("{%s, %s}, ", k, v));
  
   	} // main
  }

14-13 메서드 참조(method reference)

• 하나의 메서드만 호출하는 람다식은 ‘메서드 참조’로 더 간단히 할 수 있다.

  → 메서드 참조 == 람다식을 더 간단히 한 것

  종류	람다	메서드 참조
  static 메서드 참조	(x) → ClassName.method(x)	ClassName::method
  인스턴스 메서드 참조	(obj, x) → obj.method(x)	ClassName::method
  특정 객체 인스턴스 메서드 참조	(x) → obj.method(x)	obj::method

• static 메서드 참조

  ▼

  ▼

// 그저 Integer.parseInt(String s) 만 호출
Integer method(String s) { 
		return Integer.parseInt(s);
}

int result = obj.method("123");
int result = Integer.parseInt("123");

Function<String, Integer> f 
= (String s) -> Integer.parseInt(s); // 람다식

// 함수형 인터페이스에 정보가 다 있기 때문에 지울 수 있음
Function<String, Integer> f = Integer::parseInt; // 메서드 참조

• 예제

  Function<String, Integer> f = s -> Integer.parseInt(s); // 람다식
  Function<String, Integer> f2 = Integer::parseInt; // 메서드 참조, 입력이 String 이라는 건 함수형 인터페이스에 정보가 다 있기 때문에 안 쓸 수 있다.
  System.out.println(f.apply("100") + 200);
  System.out.println(f2.apply("300") + 100);
  
  // 메서드 참조 -> 람다식
  // 1. 입력을 쓴다.
  // 2. "::" -> "."
  // 3. 매개변수를 넣어준다.
  Function<String, Integer> f3 = (s) -> Integer.parseInt(s);

14-14 생성자와 메서드 참조

• 생성자와 메서드 참조

  Supplier<MyClass> s = () -> new MyClass();

  ▶︎

  Supplier<MyClass> s = MyClass::new;

  생성자에 매개변수가 있는 경우

  Function<Integer, MyClass> s = i -> new MyClass(i);

  ▶︎

  Function<Integer, MyClass> s = MyClass:new;

• 배열과 메서드 참조

  Function<Integer, int[]> f = x -> new int[x]; // 람다식
  Function<Integer, int[]> f = int[]::new;      // 메서드참조 - 이거 많이 쓴다고 함

• 예제

  Supplier<MyClass> s = () -> new MyClass(); // 람다식
  Supplier<MyClass> s2 = MyClass::new;       // 메서드 참조
  MyClass mc = s.get();
  System.out.println(mc);
  
  Function<Integer, MyClass> f = i -> new MyClass(i);
  Function<Integer, MyClass> f2 = MyClass::new;
  System.out.println(f2.apply(100).iv);
  
  
  BiFunction<Integer, String, MyClass> b = (i, str) -> new MyClass(i, str);
  BiFunction<Integer, String, MyClass> b2 = MyClass::new;
  System.out.println(b2.apply(21, "방채민").str);
  
  Function<Integer, int[]> f3 = i -> new int[i]; // 람다식
  Function<Integer, int[]> f4 = int[]::new;      // 메서드 참조
  int[] arr = f4.apply(99);
  System.out.println("arr.length = " + arr.length);

14-15 스트림(Stream)

• 다양한 데이터 소스를 표준화된 방법으로 다루기 위한 것

스트림 : 데이터의 연속적인 흐름

<스트림 작업 3단계>

1. 스트림 만들기

2. 중간 연산(0~n번)

3. 최종연산(0~1번)

• 스트림이 제공하는 기능 - 중간 연산과 최종 연산

  💡

  중간 연산 - 연산 결과가 스트림인 연산. 반복적으로 적용 가능
  최종 연산 - 연산 결과가 스트림이 아닌 연산. 단 한 번만 적용가능(스트림의 요소를 소모)
  

  

14-17~22 스트림 만들기

컬렉션

Collection 인터페이스의 stream()으로 컬렉션을 스트림으로 변경

💡

Stream<E> stream() // Collection 인터페이스의 메서드

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> intStream = list.stream(); // list를 stream으로 변환(list를 데이터 소스로 하는 새로운 스트림을 생성)

// stream은 1회용. stream에 대해 최종연산을 수행하면 stream이 닫힌다.
intStream.forEach(System.out::print); // 메서드 참조, 12345
intStream.forEach(System.out::print); // 에러. 스트림이 이미 닫혔다.

배열

• 객체 배열로부터 스트림 생성하기

  Stream<T> Stream.of(T... values) // 가변인자
  Stream<T> Stream.of(T[])
  Stream<T> Arrays.stream(T[])
  Stream<T> Arrays.stream(T[] array, int startInclusive, int endExclusive)
  
  Stream<String> strStream = Stream.of("a", "b", "c");
  Stream<String> strStream = Stream.of(new String[] {"a", "b", "c"});
  Stream<String> strStream = Arrays.stream(new String[] {"a", "b", "c"});
  Stream<String> strStream = Arrays.stream(new String[] {"a", "b", "c"}, 0, 3);

• 기본형 배열로부터 스트림 생성하기

  IntStream IntStream.of(int... values) // Stream이 아니라 IntStream
  IntStream IntStream.of(int[])
  IntStream Arrays.stream(int[])
  IntStream Arrays.stream(int[] array, int startInclusive, int endExclusive)

String[] strArr = {"a", "b", "c", "d"};
// Stream<String> strStream = Stream.of(strArr);
Stream<String> strStream = Arrays.stream(strArr);
strStream.forEach(System.out::print);

int[] intArr = {1, 2, 3, 4, 5};
IntStream intStream = Arrays.stream(intArr);
System.out.println(intStream.sum()); // count(), average() - 최종연산

,
Integer[] intArr = {new Integer(1), 2, 3, 4, 5};
Stream<Integer> intStream = Arrays.stream(intArr);
// 객체 스트림은 count()밖에 없음
//  숫자 외에도 여러 타입의 스트림이 가능해야하므로 숫자 스트림에만 사용할 수 있는 sum(), average()를 넣지 않은 것
System.out.println(intStream.count());

기본형 배열일 때는 IntStream 써주는 게 좋다.

임의의 수

• 난수를 요소로 갖는 스트림 생성하기

  IntStream intStream = new Random().inits(); // 무한 스트림
  intStream.limit(5).forEach(System.out::println); // 5개의 요소만 출력한다.
  
  IntStream intStream = new Random().ints(5); // 크기가 5인 난수 스트림을 반환

• 지정된 범위의 난수를 요소로 갖는 스트림을 생성하는 메서드(Random 클래스)

  IntStream ints(int begin, int end)                    // 무한 스트림
  LongStream longs(long begin, long end)
  DoubleStream doubles(double begin, double end)
  
  IntStream ints(long, streamSize, int begin, int end)  // 유한 스트림
  LongStream longs(long, streamSize, long begin, long end)
  DoulbeStream longs(long, streamSize, double begin, double end)

• 예제?

  // IntStream intStream = new Random().ints(); // 무한 스트림
  // IntStream intStream = new Random().ints(5); // 유한 스트림
  IntStream intStream = new Random().ints(5, 100); // 무한 스트림
  intStream
      .limit(10) // 5개만 자르기
      .forEach(System.out::println);

스트림 만들기 - 특정 범위의 정수

특정 범위의 정수를 요소로 갖는 스트림 생성하기(IntStream, LongStream)

💡

IntStream IntStream.range(int begin, int end) // end 미포함
IntStream IntStream.rangeClosed(int begin, int end) // end 포함

IntStream intStream = IntStream.range(1, 5);
IntStream intStream = IntStream.rangeClosed(1, 5);

스트림 만들기 - 람다식 iterate(), generate()

• 람다식을 소스로 하는 스트림 생성하기

  static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) // 이전 요소에 종속적
  static <T> Stream<T> generate(Supplier<T> s)             // 이전 요소에 독립적

• iterate()는 이전 요소를 seed로 해서 다음 요소를 계산한다.

  Stream<Integer> evenStream = Stream.iterator(0, n -> n + 2); // 0, 2, 4, 6 ... 무한 스트림 

  

• generate()는 seed를 사용하지 않는다.

  Stream<Double> randomStream = Stream.generate(Math::random);
  Stream<Double> oneStream    = Stream.generate(() -> 1);

스트림 만들기 - 파일과 빈 스트림

• 파일을 소스로 하는 스트림 생성하기

  Stream<Path> Files.list(Path dir) // Path는 파일 또는 디렉토리

  Stream<String> Files.lines(Path path)
  Stream<String> Files.lines(Path path, Charset cs)
  Stream<String> lines() // BufferedReader 클래스의 메서드

• 비어있는 스트림 생성하기

  Stream emptyStream = Stream.empty(); // empty()는 빈 스트림을 생성해서 반환한다.
  long count = emptyStream.count();    // count의 값은 0

14-23 스트림의 연산

• 스트림이 제공하는 기능 - 중간 연산과 최종 연산

14-26~29 스트림의 중간연산

스트림 자르기 - skip(), limit()

Stream<T> skip(long n)         // 앞에서부터 n개 건너뛰기
Stream<T> limit(long maxSize() // maxSize 이후의 요소는 잘라냄

IntStream intStream = IntStream.rangeClosed(1, 10); // 12345678910
intStream.skip(3).limit(5).forEach(System.out::print);; // 45678

스트림의 요소 걸러내기 - filter(), distinct()

Stream<T> filter(Predicate<? super T> predicate) // 조건에 맞지 않는 요소 제거
Stream<T> distinct()                             // 중복제거

IntStream intStream = IntStream.of(1, 2, 2, 3, 3, 4, 5, 5, 6);
intStream.distinct().forEach(System.out::print); // 123456

IntStream intStream = IntStream.rangeClosed(1, 10); // 12345678910
intStream.filter(i -> i % 2 == 0).forEach(System.out::print);; // 246810 짝수 값만 남긴다.

// 중간연산이라 filter 여러번 사용 가능
intStream.filter(i -> i % 2 != 0 && i % 3 != 0).forEach(System.out::print);
intStream.filter(i -> i % 2 != 0).filter(i -> i % 3 != 0).forEach(System.out::print);

스트림 정렬하기 - sorted()

Stream<T> sorted()                                  // 스트림 요소의 기본 정렬(Comparable)로 정렬
Stream<T> sorted(Comparator<? supter T> comparator) // 지정된 Comparator로 정렬

Comparator의 comparing()으로 정렬 기준을 제공(반환타입이 comparator임)

💡

comparing(Function<T,U> keyExtractor)
comparing(Function<T,U> keyExtractor, Comparator<U> keyComparator)

studentStream.sorted(Comparator.comparing(Student::getBan)
						 .forEach(System.out::println);

추가 정렬 기준을 제공할 때는 thenComparing()을 사용

💡

thenComparing(Comparator<T> other)
thenComparing(Function<T,U> keyExtractor)
thenComparing(Function<T,U> keyExtractor, Comparator<U> keyComp)

studentStream.sorted(Comparator.comparing(Student::getBan) // 반별로 정렬
						 .thenComparing(Student::getTotalScore)        // 총점별로 정렬
						 .thenComparing(Student::getName))             // 이름별로 정렬
						 .forEach(System.out::println);

스트림의 요소 반환하기 - map()

💡

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

Stream<File> fileStream = Stream.of(new File("Ex1.java"), new File("Ex1.bak"),
					new File("Ex2.java"), new File("Ex1"), new File("Ex1.txt")); // 위의 file 객체를 stream으로 만들었다.

Stream<String> fileNameStream = fileStream.map(File::getName);
fileNameStream.forEach(System.out::println); // 스트림의 모든 파일의 이름을 출력

예제) 파일 스트림(Stream<File>)에서 파일 확장자(대문자)를 중복없이 뽑아내기

fileStream.map(File::getName)                          // Stream<FIle> -> Stream<String>
          .filter(s -> s.indexOf(".") != -1)           // 확장자가 없는 것은 제외
          .map(s -> s.substring(s.indexOf(".") + 1))   // 확장자만 추출 
          .map(String::toUpperCase)                    // 모두 대문자로 변환
          .distinct()                                  // 중복 제거
          .forEach(System.out::println);               // JAVABAKTXT

• 예제 14-6

  package chapter14;
  
  import java.io.*;
  import java.util.stream.*;
  
  class Main {
      public static void main(String[] args) {
          File[] fileArr = {new File("Ex1.java"), new File("Ex1.bak")
              , new File("Ex2.java"), new File("Ex1"), new File("Ex1.txt")
          }; // file 객체들이 들어가있는 배열
  
          Stream<File> fileStream = Stream.of(fileArr); // 위의 file 객체를 stream으로 만들었다.
          Stream<String> fileNameStream = fileStream.map(File::getName);
          fileNameStream.forEach(System.out::println);
          System.out.println("###########");
  
          fileStream = Stream.of(fileArr);                            // fileStream을 다시 생성
          fileStream.map(File::getName)                               // Stream<FIle> -> Stream<String>
                    .filter(s -> s.indexOf(".") != -1)           // 확장자가 없는 것은 제외
                    .map(s -> s.substring(s.indexOf(".") + 1))   // 확장자만 추출 
                    .map(String::toUpperCase)                         // 모두 대문자로 변환
                    .distinct()                                       // 중복 제거
                    .forEach(System.out::println);                    // JAVABAKTXT
      }
  }

스트림의 요소를 소비하지 않고 엿보기 - peek()

Stream<T> peek(Consumer<? super T> action)    // 중간 연산(스트림을 소비X)
void      forEach(Consumer<? super T> action) // 중간 연산(스트림을 소비O)

fileStream = Stream.of(fileArr);                               // fileStream을 다시 생성
fileStream.map(File::getName)                                  // Stream<FIle> -> Stream<String>
          .filter(s -> s.indexOf(".") != -1)                   // 확장자가 없는 것은 제외
          .peek(s -> System.out.printf("fileName = %s%n", s))
          .map(s -> s.substring(s.indexOf(".") + 1))           // 확장자만 추출 
          .peek(s -> System.out.printf("extension = %s%n", s)) 
          .forEach(System.out::println);                       // 최종연산 스트림을 소비

스트림의 스트림을 스트림으로 변환 - flatMap()

Stream<String[]> strArrStream = Stream.of()

• 예제 14-7

  package chapter14;
  
  import java.util.*;
  import java.util.stream.*;
  
  class Ex14_7 {
  	public static void main(String[] args) {
  		Stream<String[]> strArrStrm = Stream.of(
  			new String[]{"abc", "def", "jkl"},
  			new String[]{"ABC", "GHI", "JKL"}
  		);
  
      // Stream<Stream<String>> strStrmStrm = strArrStrm.map(Arrays::stream); // 배열을 주면 stream으로 바꾼다. 스트림의 스트림이 생성됨
  		Stream<String> strStrm = strArrStrm.flatMap(Arrays::stream);
  
  		strStrm.map(String::toLowerCase)
  			   .distinct()
  			   .sorted()
  			   .forEach(System.out::println);
  		System.out.println();
  
  		String[] lineArr = {
  			"Believe or not It is true",
  			"Do or do not There is no try",
  		};
  
  		Stream<String> lineStream = Arrays.stream(lineArr);
  
  		lineStream.flatMap(line -> Stream.of(line.split(" +")))
  			.map(String::toLowerCase)
  			.distinct()
  			.sorted()
  			.forEach(System.out::println);
  		System.out.println();
  	}
  }

14-35 Optional<T>

• T 타입 객체의 래퍼클래스 - Optional<T>

  public final class Optional<T> {
  		private final T value; // T타입의 참조변수
  				...
  }

14-36 Optional<T> 객체 생성하기

• Optional<T> 객체를 생성하는 다양한 방법

  String str = "abc";
  Optional<String> optVal  = Optional.of(str);
  Optional<String> optVal2 = Optional.of("abc");
  Optional<String> optVal3 = Optional.of(null);  // NullPointerException 발생
  Optional<String> optVal4 = Optional.ofNullable(null); // OK

  public final class Optional<T> {
  		...
      private final T value;
  		...
  }

  

• null대신 빈 Optional<T> 객체를 사용하자

  Optional<String> optVal = null;              // 널로 초기화. 바람직하지 않음
  Optional<String> optVal2 = Optional.empty(); // 빈 객체로 초기화

14-37 Optional<T> 객체의

• Optional 객체의 값 가져오기 - get(), orEls(), orElseGet(), orElseThrow()

  Optional<String> optVal = Optional.of("abc");
  String str1 = optVal.get();                  // optVal에 저장된 값을 반환. null이면 예외발생
  String str2 = optVal.orElse("");             // optVal에 저장된 값이 null일 때는, ""를 반환
  String str3 = optVal.orElseGet(String::new); // 람다식 사용가능 () -> new String()
  String str4 = optVal.orElseThrow(NullPointerException::new); // 널이면 예외발생

• isPresent() - Optional 객체의 값이 null이면 false, 아니면 true를 반환

  if (Optional.ofNullable(str).isPresent()) {
  		System.out.println(str);
  }
  
  // ifPresent(Consumer) - 널이 아닐 때만 작업 수행, 널이면 아무 일도 안함
  Optional.ofNullable(str).ifPresent(System.out::println);

예제

// int[] arr = null; // NEP 발생
int[] arr = new int[0];
System.out.println("arr.length = " + arr.length);

// Optional<String> opt = null; //  OK. 하지만 바람직X
Optional<String> opt = Optional.empty();
// Optional<String> opt = Optional.of("abc");
System.out.println("opt" + opt);
// System.out.println("opt" + opt.get());

String str = "";
// try {
//     str = opt.get();
// } catch (Exception e) {
//     str = ""; // 예외가 발생하면 빈문자열("")로 초기화
// }

str = opt.orElse("EMPTY");         // Optinal에 저장된 값이 null이면 "EMPTY" 반환
str = opt.orElseGet(() -> new String()); // Optinal에 저장된 값이 null이면 "" 반환
str = opt.orElseGet(String::new);        // Optinal에 저장된 값이 null이면 "" 반환

System.out.println("str = " + str);

14-38 OptionallInt, OptionalLong, OptionalDouble

• 기본형 값을 감싸는 래퍼클래스(성능 때문에 사용한다.)

  public final class OptionalInt {
  		...
  		private final boolean isPresent; // 값이 저장되어 있으면 true
  		private final int value;         // int 타입의 변수
  }

• OptionallInt의 값 가져오기 - int getAsInt()

  Optinal 클래스	값을 반환하는 메서드
  Optional<T>	T get()
  OptionalInt	int getAsInt()
  OptionalLong	long getAsLong()
  OptionalDouble	double getAsDouble()

• 빈 Optional 객체와의 비교

  OptionalInt opt = OptionalInt.of(0);    // OptionalInt에 0을 저장
  OptionalInt opt2 = OptionalInt.empty(); // OptionalInt에 0을 저장
  
  System.out.println(opt.isPresent());    // true
  System.out.println(opt2.isPresent());   // false
  System.out.println(opt.equals(opt2));   // false

14-40 스트림의 최종연산 - forEach()

• 스트림의 모든 요소에 지정된 작업을 수행 - forEach(), forEachOrdered()

  아래 두 메서드는 근본적으로 같은데 병렬일 때 차이가난다.

  void forEach(Consumer<? super T> action)        // 병렬스트림인 경우 순서가 보장되지 않음
  void forEachOrdered(Consumer<? super T> action) // 병렬스트림인 경우에도 순서가 보장됨

  // 직렬 스트림, 스트림은 기본적으로 직렬이기 때문에 생략 가능
  IntStream.range(1, 10).sequential().forEach(System.out::println);
  IntStream.range(1, 10).sequential().forEachOrdered(System.out::println);

  // 병렬 스트림
  IntStream.range(1, 10).parallel().forEach(System.out::println);
  IntStream.range(1, 10).parallel().forEachOrdered(System.out::println);

병렬 → 여러 쓰레드가 나눠서 작업한다.

14-41 스트림의 최종연산 - 조건 검사

• allMath(), anyMatch(), noneMatch()

  boolean allMatch (Predicate<? super T> predicate) // 모든 요소가 조건을 만족시키면 true
  boolean anyMatch (Predicate<? super T> predicate) // 한 요소라도 조건을 만족시키면 true
  boolean noneMatch (Predicate<? super T> predicate) // 모든 요소가 조건을 만족시키지 않으면 true

  boolean hasFailedStu = studentStream.anyMatch(s -> s.getTotalScore() <= 100); // 낙제자가 있는지?

• 조건에 일치하는 요소 찾기 - findFirst(), findAny()

  조건에 맞는 게 없을 수도 있기 때문에 Optional로 되어있다.

  Optional<T> findFirst() // 첫 번째 요소를 반환. 순차 스트림에 사용
  Optional<T> findAny()   // 아무거나 하나를 반환. 병렬 스트림에 사용

  Optional<Student> result = studentStream.filter(s -> s.getTotalScore() <= 100).findFirst();
  Optional<Student> result = studentStream.parallel().filter(s -> s.getTotalScore() >= 100).findAny();

14-42, 43 스트림의 최종연산 - reduce()

스트림의 최종연산 중에 제일 중요하다. / accumulate - 누적하다

• 스트림의 요소를 하나씩 줄여가며 누적연산 수행 - reduce()

  

핵심 : reduce(identity, accumulator)

14-45 collector()와 Collectors

최종연산

1. reduce() : 리듀싱

2. collect() : 그룹별 리듀싱

collect() : 최종연산

collector : 인터페이스

collectors : 클래스

• collect()는 Collector를 매개변수로 하는 스트림의 최종연산

14-46 스트림을 컬렉션, 배열로 변환

• 스트림을 컬렉션으로 변환 - toList(), toSet(), toMap(), toCollection()

  List<String> names = stuStream.map(Student::getName)         // Stream<Student> -> Stream<String>
  															.collect(Collectors.toList()); // Stream<String> -> List<String>
  ArrayList<String> list = names.stream()
  	                            .collect(Collectors.toList()); // Stream<String> -> ArrayList<String>
  Map<String, Person> map = personStream
  	.collect(Collectors.toMap(p -> p.getRegId(), p -> p)); // Stream<Person> -> Map<String, Person>

• 스트림을 배열로 변환 - toArray()

  Student[] stuNames = studentStream.toArray(Student[]::new); // OK
  Student[] stuNames = studentStream.toArray(); // 에러
  Object[] stuNames = studentStream.toArray(); // OK.

14-47 스트림의 통계 - counting(), summingInt()

• 스트림의 통계정보 제공 - counting(), summingInt(), maxBy(), minBy(), …

  long count = stuStream.count();
  long count = stuStream.collect(counting()); // Collectors.counting()

  long totalScore = stuStream.mapToInt(Student::getTotalScore).sum(); // IntStream의 sum(), 전체만 가능
  long totalScore = stuStream.collect(summingInt(Student::getTotalScore)); // 그룹별 가능
  

14-48 스트림을 리듀싱 - reducing()

• 스트림을 리듀싱 - reducing()

  

14-53 스트림의 그룹화 - groupingBy()

• 스트림의 요소를 그룹화

  Collector groupingBy(Function classifier)
  Collector groupingBy(Function classifier, Collector downstream)
  Collector groupingBy(Function classifier, Supplier mapFactory, Collector downstream)

  Map<Integer, List<Student>> stuByBan = stuStream               // 학생을 반별로 그룹화
  							.collect(groupingBy(Student::getBan, toList())); // toList() 생략가능

  Map<Integer, Map<Integer, List<Student>> stuByHak // 다중 그룹화
  stuStream.collect(groupingBy(Student::getHak,     // 1. 학년별 그룹화
  									groupingBy(Student::getBan)     // 2. 반별 그룹화
  					));

• 스트림의 요소를 2분할

  

Uploaded by N2T