[Java 8] java.util.function

Java가 제공하는 주요 함수형 인터페이스

• java.util.function 👉 Java에서 자주 사용되는 함수형 인터페이스를 미리 정의해둔 패키지

대표적인 함수형 인터페이스

• Function<T, R>
• BiFunction<T, U, R>
• Consumer< T >
• Supplier< T >
• Predicate< T >
• UnaryOperator< T >
• BinaryOperator< T >

---

Function<T, R>

• T 타입을 받아서 R 타입을 리턴하는 함수형 인터페이스

  • Integer 타입을 받아서 Integer 타입을 리턴하는 예제

		// Function<T,R>
        Function<Integer, Integer> plus10 = (i) -> i + 10;
        Function<Integer, Integer> multiply2 = (i) -> i * 2;

        plus10.andThen(multiply2).apply(2); // (10 + 2) * 2 = 24
        plus10.compose(multiply2).apply(2); // (2 * 2) + 10 = 14

• apply()를 통해 매개변수 전달 가능

• default 메소드 andThen(), compose()

  • andThen()에 넘겨진 함수는 나중에 매개변수 적용
  • compose()에 넘겨진 함수는 먼저 매개변수 적용

---

BiFunction<T,U,R>

• 두 개의 입력 값(T, U)를 받아서 R 타입을 리턴하는 함수형 인터페이스

		// BiFunction<T,U,R>
        BiFunction<Integer, Integer, Integer> addTwoInt = (a, b) -> a + b;

        int res = addTwoInt.apply(10,15);

        System.out.println(res);

---

Consumer< T >

• T 타입을 받아서 아무 값도 리턴하지 않는 함수형 인터페이스

  • 소비자라고도 한다, accept를 통해 값을 전달할 수 있다.

		// Consumer<T>
		Consumer<Integer> printInt = input -> System.out.println(input);
        
		printInt.accept(10);

---

Supplier< T >

• T 타입의 값을 제공하는 함수형 인터페이스

  • 공급자라고도 불린다, T에는 받아올 값의 타입을 명시한다.

		// Supplier<T>
        Supplier<Integer> get20 = () -> 20;

        int res2 = get20.get();

---

Predicate< T >

• T타입을 받아서 boolean을 리턴하는 함수형 인터페이스

  • test()로 값을 넘길 수 있으며,
  • 함수 조합용 메서드인 or, and, negate 등을 통해 조합을 할 수 있다.

		// Predicate<T>
        Predicate<String> startWithHong = str -> str.startsWith("Hong");

        boolean res3 = startWithHong.test("HongJungWan");

---

UnaryOperator< T >

• 앞서 살펴본 Function<T, R>의 특수한 형태

  • Function<T, R>의 입력 타입 T와 리턴 타입 R이 같을 경우 UnaryOperator< T >로 사용할 수 있다.

		// UnaryOperator<T>
        UnaryOperator<Integer> plus30U = input -> input + 30;

        int res4 = plus30U.apply(30);

---

BinaryOperator< T >

• BinaryOperator는 BiFunction<T, U, R>의 특수한 형태

  • 입력과 출력의 타입이 다를 거라는 가정하에 만들어진 BiFunction과는 다르게
  • 타입이 하나로 사용될 것을 고려해 만들어진 함수형 인터페이스

		// BinaryOperator<T>
        BinaryOperator<Integer> addTwoIntB0 = (a, b) -> a + b;

        int res5 = addTwoIntB0.apply(20, 80);