JAVA 함수형 인터페이스 API

JAVA에서 제공하는 함수형 인터페이스 4가지.

 

1. Supplier<T>
2. Consumer<T>
3. Function<T, R>
4. Predicate<T>

---

1. Suppiler<T>

• 매개변수 없이 반환값만을 갖습니다.
• 추상메소드로 T get()을 갖고있습니다.

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

public class Lambda {

    public static void main(String[] args) { 
        Supplier<String> supplier = () -> "Hello, World.";
        System.out.println( supplier.get() );
    }

}

 

2. Consumer<T>

• 매개변수 T를 받아 사용하며, 반환값이 없습니다.
• 추상메소드로 void accept(T t)을 갖고있습니다.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
    	Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t) };
    }
}

public class Lambda {

    public static void main(String[] args) {
        Consumer<String> consumer = str -> System.out.println( str.toUpperCase() );
        consumer.accept("hello, world");
        // 출력 : HELLO WORLD
        
        List<String> list = Arrays.asList("apple", "banana", "orange");
        list.forEach(consumer); // .forEach 함수는 Consumer객체를 매개변수로 받을 수 있다.
        /* 출력
           APPLE
           BANANA
           ORANGE */
    }

}

• andThen이라는 함수가 존재합니다. 이 함수를 이용하여, 하나의 함수가 끝난 후 다시 Consumer객체를 연쇄적으로 사용할 수 있습니다.

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample4 {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "orange");

        Consumer<List<String>> addNumber = list -> {
            for (int i = 0; i < list.size(); i++) {
                list.set(i, (i + 1) + ". " + list.get(i));
            }
        };

        Consumer<List<String>> printList = list -> {
            for (String fruit : list) {
                System.out.println(fruit);
            }
        };

        addNumber.andThen(printList).accept(fruits); // accept실행 후 andThen실행
        /* 출력
          1. apple
          2. banana
          3. orange
    }
}

 

3. Function<T,R>

• 매개변수 T를 처리한 후 R로 반환합니다.
• 추상메소드로 R apply(T t)을 갖고있습니다.
• Consumer와 마찬가지로 andThen 함수가 존재합니다.
• compose라는 함수가 존재합니다. andThen은 첫 번째 함수를 실행 후 다음 함수를 실행하도록 해준다고 한 것과 반대로, 이 함수는 첫 번째 함수가 실행되기 전에 실행을 합니다.
• identity 함수가 존재합니다. 이 함수는 자기 자신을 반환하는 static함수입니다.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    
    static <T> Function<T, T> identity() {
        return t -> t;
    }

}

// apply 예제
public static void main(String[] args) {
    Function<Integer, Integer> func1 = x -> x * x;
    Integer result = func1.apply(10);
    
    System.out.println(result);
    // 출력 : 100
}

// compose 예제
public static void main(String[] args) {
    Function<Integer, Double> add = n -> n + 2.0;
    Function<Double, Double> multiply = n -> n * 5.0;
    Function<Integer, Double> addAndMultiply = multiply.compose(add);

    Double result = addAndMultiply.apply(1);

    System.out.println(result);
    // 출력 : 15.0
}

 

4. Predicate<T>

• 매개변수 T를 처리한 후 Boolean을 반환합니다.
• 추상메소드로 Boolean test(T t)을 갖고있습니다.

@FunctionalInterface
    public interface Predicate<T> {
        boolean test(T t);
        default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object);
    }

}