자바 람다(Java Lambda) - 2 (자바 함수형 인터페이스)

Java가 기본으로 제공하는 함수형 인터페이스

• util.function 패키지

• 자바에서 미리 정의해둔 자주 사용할만한 함수 인터페이스

• Function<T, R>

• BiFunction<T, U, R>

• Consumer<T>

• Supplier<T>

• Predicate<T>

• UnaryOperator<T>

• BinaryOperator<T>

---

Function<T, R>

• T 타입을 받아서 R 타입을 리턴하는 함수 인터페이스
  • 입력과 출력의 타입이 다를 수 있기 때문에 T와 R로 구분한다.
  • R apply(T t)

• 함수 조합용 메소드
  • andThen
  • compose

/**
 * Function<T, R>
 */
public class Plus10 implements Function<Integer, Integer> {

    @Override
    public Integer apply(Integer integer) {
        return integer + 10;
    }
}

public class Main {
    public static void main(String[] args){
        //1. Function<T, R> 인터페이스를 구현한 클래스를 사용.
        Plus10 plus10 = new Plus10();
        System.out.println(plus10.apply(1));
        System.out.println("#########################");

        //2. 람다 표현식으로 사용.
        Function<Integer, Integer> plus20 = (i) -> i + 20;
        System.out.println(plus20.apply(1));
        System.out.println("#########################");

        Function<Integer, Integer> multiply2 = (i) -> i * 2;
        System.out.println(multiply2.apply(1));
        System.out.println("#########################");

        //3. 함수를 조합하여 사용.
        //함수 조합용 메소드 : compose, andThen
        //compose 메소드는 입력 값을 인자로 전달한 함수를 먼저 적용하고 결과 값을 plus10의 입력 값으로 전달하여 동작.
        //T를 넣으면 multiply2를 수행하고 그 결과를 plus20 수행.
        //2 * 2 + 20 = 24
        Function<Integer, Integer> multiply2AndPlus20 = plus20.compose(multiply2);
        System.out.println(multiply2AndPlus20.apply(2));
        System.out.println("#########################");
        //andThen 메소드는 입력 값을 plus20을 먼저 적용하고 그 결과를 인자로 전달한 함수의 입력 값으로 사용하여 동작.
        //20+2 * 2 = 44
        Function<Integer, Integer> plus20AndMultiply2 = plus20.andThen(multiply2);
        System.out.println(plus20AndMultiply2.apply(2));
        System.out.println(plus20.andThen(multiply2).apply(2));
    }
}

---

BiFunction<T, U, R>

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

public class Main {

    public static void main(String[] args){
        BiFunction<Integer, Integer, Integer> plus = (i, j) -> i + j;
        System.out.println(plus.apply(10, 20)); // 10 + 20 = 30
        System.out.println("######################");
        BiFunction<Integer, Integer, Integer> multiply = (i, j) -> i * j;
        System.out.println(multiply.apply(10, 20)); // 10 * 20 = 200
        System.out.println("######################");
        //함수를 조합해서 사용.
        UnaryOperator<Integer> minus = (i) -> i - 50; //Function<Integer, Integer> minus = (i) -> i - 50;
        System.out.println(plus.andThen(minus).apply(20, 30)); //(20 + 30) - 50 = 0
        System.out.println("######################");
        System.out.println(multiply.andThen(minus).apply(20, 30)); //(20 * 30) - 50 = 550
    }
}

---

Consumer<T>

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

• 함수 조합용 메소드
  • andThen

public class Main {
    public static void main(String[] args) {
        //Consumer<T> : 받아서 아무것도 리턴하지 않음, 내부에서 받은 인자를 소비만 한다.
        Consumer<Integer> printT = (i) -> System.out.println(i);
        printT.accept(10);
    }
}

---

Supplier<T>

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

public class Main {
    public static void main(String[] args){
        //인자를 받지 않고 해당하는 타입의 인자를 내부에서 생성하여 반환하기만 한다.
        Supplier<Integer> get10 = () -> 10;
        System.out.println(get10);
        System.out.println(get10.get());
    }
}

---

Predicate<T>

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

• 함수 조합용 메소드
  • And
  • Or
  • Negate

public class Main {
    public static void main(String[] args) {
        //인자를 하나 받아서 true, false를 반환해주는 함수형 인터페이스
        Predicate<String> startWithDevHistory = (s) -> s.startsWith("DevHistory");
        //짝수 검사
        Predicate<Integer> isEven = (i) -> i%2 == 0;

        System.out.println(startWithDevHistory.test("DevHistory"));
        System.out.println(startWithDevHistory.test("DevHistory2"));
        System.out.println(startWithDevHistory.test("NoDevHistory2"));
        System.out.println("#################################");
        //결과에 not을 취함
        Predicate<String> notStartWithDevHistory = startWithDevHistory.negate();
        System.out.println(notStartWithDevHistory.test("DevHistory"));
        System.out.println(notStartWithDevHistory.test("DevHistory2"));
        System.out.println(notStartWithDevHistory.test("NoDevHistory"));
        System.out.println("#################################");
        //OR 연산
        System.out.println(startWithDevHistory.or(notStartWithDevHistory).test("DevHistory"));
        //AND 연산
        System.out.println(startWithDevHistory.and(notStartWithDevHistory).test("DevHistory"));

    }
}

---

UnaryOperator<T>

• Function<T, R>의 특수한 형태로, 입력값 하나를 받아서 동일한 타입을 리턴하는 함수 인터페이스

public class Main {
    public static void main(String[] args){
        Function<Integer, Integer> plus20 = (i) -> i + 20;
        Function<Integer, Integer> multiply2 = (i) -> i * 2;

        // Function 인터페이스의 특수한 형태.
        // 위와 같이 입력하는 값과 반환하는 값의 타입이 같다면 사용 가능.
        // Function 인터페이스를 상속받았다.
        UnaryOperator<Integer> plus30 = (i) -> i + 30; // ==Function<Integer, Integer> plus30 = (i) -> i + 30;
        UnaryOperator<Integer> multiply4 = (i) -> i * 4; // ==Function<Integer, Integer> multiply4 = (i) -> i * 4;
        System.out.println(plus30.apply(30));
        System.out.println(multiply4.apply(30));
        System.out.println(plus30.andThen(multiply4).apply(40));
        System.out.println(plus30.compose(multiply4).apply(40));
        System.out.println(plus30.andThen(plus20).andThen(multiply2).andThen(multiply4).apply(30));
    }
}

---

BinaryOperator<T>

• BiFunction<T, U, R>의 특수한 형태로, 동일한 타입의 입력값 두 개를 받아 리턴하는 함수 인터페이스

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> plus = (i, j) -> i + j;
        BiFunction<Integer, Integer, Integer> multiply = (i, j) -> i * j;

        // BiFunction<T, U, R> 인터페이스의 특수한 형태.
        // 3개(입력하는 값 2개, 반환하는 값 1개)의 타입이 모두 같은 경우에 사용 가능
        // BiFunction 인터페이스를 상속받았다.
        BinaryOperator<Integer> minus = (i, j) -> i - j; //==BiFunction<Integer, Integer, Integer> minus = (i, j) -> i - j;
        System.out.println(minus.apply(20, 10));
    }
}

---

[참고자료]

더 자바, Java 8, 백기선