자바8 - 자바에서 제공하는 함수형 인터페이스

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

• Function<T,R>

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

    • R apply(T t)

  • 함수 조합용 메소드

    • andThen
    • compose

• BiFunction<T,U,R>

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

    • R apply(T t, U u)

• Consumer<T>

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

    • void Accept(T t)

  • 함수 조합용 메소드

    • andThen

• Supplier<T>

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

    • T get()

• Predicate<T>

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

    • boolean test(T t)

  • 함수 조합용 메소드

    • And
      • Or
      • Negate

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

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

Function<T,R>

• T(Parameter)를 받아서 R값을 Return 해주는 인터페이스

public class Plus10 implements Function<Integer, Integer> {
    
    @Override
    public Integer apply(Integer integer) {
        return integer + 10;
    }
}

public class Plus {


    public static void main(String[] args) {
        Plus10 plus10 = new Plus10();
        plus10.apply(1);
    }
}

위와 같이 사용할 수 있고

public class Plus {


    public static void main(String[] args) {
        Function<Integer, Integer> plus10 = (i) -> i + 10;
        plus10.apply(1);
    }
}

위처럼 별도의 클래스를 만들지 않고 람다 형식으로 사용할 수 도 있다.

그리고 Function<T,R>의 compose() 함수를 쓰면 아래처럼 람다식을 서로 합칠 수 있는데

public class Plus {


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

        Function<Integer, Integer> multiply2AndPlus10 = plus10.compose(multiply2);
        multiply2AndPlus10.apply(2);
    }
}

두 람다식이 합쳐진 plus10.compose(multiply2) 함수는 변수 값에 X2 한다음 + 10해주는 함수다.

이와 반대로 AndThen() 함수는 compose()함수와는 반대로 10을 먼저 더해주고 그 다음에 X2해주는 함수다.
public class Plus {

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

    Function<Integer, Integer> multiply2AndPlus10 = plus10.compose(multiply2);
    System.out.println("multiply2AndPlus10.apply(2) = " + multiply2AndPlus10.apply(2));

    Function<Integer, Integer> plus10AndMultiply2 = plus10.andThen(multiply2);
    System.out.println("plus10AndMultiply2.apply(2) = " + plus10AndMultiply2.apply(2));
    
}

}

BiFuntion(T,U,R)

• 이 함수는 Function<T,R>에서 변수 값이 하나 추가 된 것 뿐이다.

Consumer<T>

• 이 함수는 반환 타입 없는 인터페이스다.

public class Consume {

    public static void main(String[] args) {
        Consumer<String> printT = (s) -> System.out.println(s);
        printT.accept("Hello");
    }
}

Supplier<T>

• 어떤 값을 가져오는 인터페이스 (인자를 받지 않음)

public class Supply {

    public static void main(String[] args) {
        Supplier<Integer> get10 = () -> 10;
        get10.get();
    }
}

Predicate<T>

• T 타입을 받아 참 거짓을 구분해주는 인터페이스

public class Predict {

    public static void main(String[] args) {
        Predicate<String> startsWithHyunSik = (s) -> s.startsWith("hyunsik");
        Predicate<Integer> isOdd = (i) -> i % 2 == 1;

        System.out.println("startsWithHyunSik.test(\"hyunsikYoon\") = " + startsWithHyunSik.test("hyunsikYoon"));

        System.out.println("isOdd.test(4) = " + isOdd.test(4));
        
    }
}

UnaryOperator<T>

//        Function<Integer, Integer> plus10 = (i) -> i + 10;
        UnaryOperator<Integer> plus10 = (i) -> i + 10;

위와 같이 입력받은 타입과 리턴 타입이 같을 경우 UnaryOperator<T>로 대체 가능하다.

BinaryOperator<T>

• 입력 타입 2개와 리턴 타입 1개가 모두 같을 경우 BinaryOperator<T>로 대체 가능하다.