모던 자바 인 액션 - 자바8 함수형 인터페이스 정리

• 함수형 인터페이스 사용법
  • 함수형 인터페이스의 추상 메서드는 람다 표현식의 시그니쳐를 묘사한다. (함수 디스크립터)
  • 자바 API는 Comparable, Runnable, Callable 등의 다양한 함수형 인터페이스를 포함하고 있음
  • java 8 에서 java.util.function 패키지로 다양한 함수형 인터페이스를 제공한다.
  • 대표적인 함수형 인터페이스 3가지 - Predicate, Consumer, Function
    1. java.util.function.Predicate<T>
       • test 라는 추상메서드를 정의한다. 함수 디스크립터: T → boolean

       @FunctionalInterface
       public interface Predicate<T> {
       	boolean test(T t);
       }
       
       public <T> List<T> filter(List<T> list, Predicate<T> p) {
           List<T> results = new ArrayList<>();
           for(T t: list) {
                   if(p.test(t)) results.add(t);
           }
           return results;
       }
       
       Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
       List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

    2. java.util.function.Consumer<T>
       • accept라는 추상메서드를 정의한다. T → void

       @FunctionalInterface
       public interface Consumer<T> {
       	void accept(T t);
       }
       
       public <T> void forEach(List<T> list, Consumer<T> c) {
           for(T t: list) {
               c.accept(t);
           }
       }
       
       forEach(
           Arrays.asList(1,2,3,4,5);
           (Integer i) -> System.out.println(i);
       );

    3. java.util.function.Function<T, R>
       • apply라는 추상메서드를 정의한다. T → R
       • 입력을 출력으로 매핑하는 람다를 정의할 때 사용할 수 있다.

       @FunctionalInterface
       public interface Functaion<T, R> {
       	R apply(T t);
       }
       
       public <T, R> List<R> map(LIst<T> list, Function<T, R> f) {
           List<R> result = new ArrayList<>();
           for(T t: list) {
               result.add(f.apply(t));
           }
           return result;
       }
       
       List<Integer> l = map( // 각 문자열의 길이가 담긴 list
           Arrays.asList("lambda", "in", "action"),
           (String s) -> s.length()
       )

  • 오토박싱에 드는 비용을 피할 수 있도록 각 기본형에 특화된 함수형 인터페이스들도 있음
    • ex) IntPredicate, DoublePredicate, IntConsumer, LongBinaryOperator, IntFunction…
  • 그 외
    • Supplier<T> () → T
    • UnaryOperator<T> T → T
    • BinaryOperator<T> (T, T) → T
    • BiPredicate<L, R> (T, U) → boolean
    • BiConsumer<T, U> (T, U) → void
    • BiFunction<T, U, R> (T, U) → R
    • ...