Java8. 함수형 인터페이스 (Functional Interface)

  함수형 인터페이스란 추상 메소드를 딱 하나만 가지고 있는 인터페이스입니다. @FunctionalInterface 애노테이션을 가지고 있는 SAM (Single Abstract Method) 인터페이스입니다.

@java.lang.FunctionalInterface
public interface FunctionalInterface {

  // 추상 메서드 (abstract method)
  void printJava();

  // static method는 가질 수 있습니다.
  static void printStatic() {
    System.out.println("static method");
  }

  // default method는 가질 수 있습니다.
  default void printDefault() {
    System.out.println("default method");
  }
}

public class Java {

  public static <Fuction> void main(String[] args) {

    // 내부 익명 클래스 (anonymous inner class)
    FunctionalInterface functionalInterface = new FunctionalInterface() {
      @Override
      public void printJava() {
        System.out.println("Hello, JAVA!");
      }
    };

    // 호출
    functionalInterface.printJava();
    FunctionalInterface.printStatic();
    functionalInterface.printDefault();
  }

}

/******************************************
[결과]
Hello, JAVA!
static method
default method
*******************************************/

 

Java 기본 제공 함수형 인터페이스

Function<T, R>

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

    Function<String, String> function = new Function<String, String>() {
      @Override
      public String apply(String s) {
        return "print " + s;
      }
    };
    // Call
    System.out.println(function.apply("function")); // [결과]: print function

    // 함수 조합용 메소드 andThen, compose
    Function<Integer, Integer> plusFive = new Function<Integer, Integer>() {
      @Override
      public Integer apply(Integer integer) {
        return integer + 5;
      }
    };
    Function<Integer, Integer> multipleTwo = new Function<Integer, Integer>() {
      @Override
      public Integer apply(Integer integer) {
        return integer * 2;
      }
    };
    // multipleTwo한 결과가 plusFive의 인자로 사용됩니다.
/*
    Function<Integer, Integer> multipleTwoAndPlusFive = plusFive.compose(multipleTwo);
*/
    Function<Integer, Integer> multipleTwoAndPlusFive = multipleTwo.andThen(plusFive);

    // Call
    System.out.println(multipleTwoAndPlusFive.apply(10)); // [결과]: 25

 

Consumer<T>

  T 타입을 받아서 어떤 값도 리턴하지 않는 함수 인터페이스 (함수 조합용 메소드: andThen)

    Consumer<String> printConsumer = new Consumer<String>() {
      @Override
      public void accept(String s) {
        System.out.println("print " + s);
      }
    };
    printConsumer.accept("Consumer"); // [결과]: print Consumer

 

Supplier<T>

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

    Supplier<Integer> supplier = new Supplier<Integer>() {
      @Override
      public Integer get() {
        return 100;
      }
    };
    System.out.println(supplier.get()); // [결과]: 100

 

Predicate<T>

  T 타입을 받아서 boolean을 리턴하는 함수 인터페이스 (함수 조합용 메소드: And, Or, Negate)

    Predicate<String> bool = new Predicate<String>() {
      @Override
      public boolean test(String s) {
        return s.equals("Java");
      }
    };
    System.out.println(bool.test("Java")); // [결과]: true