Consumer、Supplier、Predicate、Function

 Java 要逐漸導入 Functional Programming，多了 Lambda、Stream 及現在要說明的 java.util.function 這個 package 下的四個 interface。

這四個 interface 都標注有 @FunctionalInterface，這表示這些 interface 只能剛剛好有一個未實作的 method! 要特別注意，Java 8 開始，interface 的 method 是可以實作非僅有宣告。

1. Consumer

@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); };
    }
}

上面是 Consumer 本身的程式碼，這個 interface 有兩個 method，僅有一個未實作的 method - accept。從名稱猜測，可以知道這是個消費者，即實作 Consumer interface 的類別要透過 accept 吃進資料並進行處理。至於 andThen 這個 method 並沒有強制要用，當有使用時，會在 accept 執行完後接著執行。

@DisplayName("ConsumerTest")
@SpringBootTest
@Slf4j
class ConsumerTest {

    @Test
    void accept() {
        Consumer<Integer> display = a -> log.debug(a.toString());
 
        display.accept(10);
 
        Consumer<List<Integer> > modify = list ->
        {
            for (int i = 0; i < list.size(); i++)
                list.set(i, 2 * list.get(i));
        };
 
        Consumer<List<Integer> >
            dispList = list -> list.stream().forEach(a -> log.debug(a + " "));
 
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(1);
        list.add(3);
 
        modify.accept(list);
 
        dispList.accept(list);
    }

    @Test
    void andThen() {
        Consumer<List<Integer> > modify = list ->
        {
            for (int i = 0; i < list.size(); i++)
                list.set(i, 2 * list.get(i));
        };
 
        Consumer<List<Integer> >
            dispList = list -> list.stream().forEach(a -> log.debug(a + " "));
 
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(1);
        list.add(3);
 
        modify.andThen(dispList).accept(list);
    }
}

上面單元測試程式，執行後第一個 method (accept) 會輸出 10 4 2 6，第二個 method (andThen) 會輸出 4 2 6，程式說明如下:
(1) 第一個單元測試 - accept()

• 第 8 行: 實做一個命名為 display 的 Consumer 實做類別，實做出 accept() method，很簡單的將收到的值輸出。
• 第 10 行: 將 10 傳入給 display 這個 Consumer 實做類別，程式會輸出 10。
• 第 12~16 行: 實做一個命名為 modify 的 Consumer 實做類別，這個類別會接收一個 List<Integer>，並將 List 的每個值乘以 2。
• 第 18 行: 實做一個命名為 dispList 實做類別，這個類別會接收一個 List<Integer>，並將 List 裡所有值輸出。
• 第 21~24 行: 產生一個 3 個元素的 List，值分別為2、1、3。
• 第 26 行: modify 將傳入的 List 裡的元素都乘以 2。
• 第 28 行: dispList 將傳入的 List 裡的元素依序輸出為 4 2 6。
(2) 第二個單元測試 - andThen()

• 第 33~37 行: 實做一個命名為 modify 的 Consumer 實做類別，這個類別會接收一個 List<Integer>，並將 List 的每個值乘以 2。
• 第 39 行: 實做一個命名為 dispList 實做類別，這個類別會接收一個 List<Integer>，並將 List 裡所有值輸出。
• 第 42~45 行: 產生一個 3 個元素的 List，值分別為2、1、3。
• 第 47 行: 會先執行 accept 將值乘 2，接著執行 andThen 將值輸出。


2. Supplier

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


Supplier 是生產者，上面是 Supplier 的程式碼，只有一個 method - get()，讓外界可以透過這個 method 取得 Supplier 實做類別裡的值。


@DisplayName("SupplierTest")
@SpringBootTest
@Slf4j
class SupplierTest {

    @Test
    void random() {
        Supplier<Double> randomValue = Math::random;
  
        log.debug(randomValue.get().toString());
    }
}

上面單元測試程式執行後，輸出 0.4077113851887808，這是個隨機值，程式說明如下:
• 第 8 行: 實做一個命名為 rendomValue 的實做類別，覆寫 get() method 為 Math:: random。
• 第 10 行: 從 randomValue 中取出值並輸出。


3. Predicate

@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);
    }

    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

Predicate 的 test method 是用來測試邏輯運算是 true 或 false，其餘 method 用來和 test 搭配出更複雜的邏輯判斷。

@DisplayName("PredicateTest")
@SpringBootTest
@Slf4j
class PredicateTest {

    @Test
    void greaterThanFive() {
	Predicate<Integer> predicate = (i) -> i > 5;

        Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
        List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
        list.forEach(item -> log.debug(Integer.toString(item)));
    }

    @Test
    void betweenTenAndTwenty() {
	Predicate<Integer> greaterThanTen = (i) -> i > 10;

        Predicate<Integer> lowerThanTwenty = (i) -> i < 20; 
        boolean result = greaterThanTen.and(lowerThanTwenty).test(15);
        log.debug("result = " + result);
 
        boolean result2 = greaterThanTen.and(lowerThanTwenty).negate().test(15);
        log.debug("result2 = " + result2);
    }
}

上面單元測試程式，執行後第一個 method (greaterThanFive) 會輸出 23 56 6 6，第二個 method (betweenTenAndTwenty) 會輸出 result = true、result2 = false，程式說明如下:
• 第 8 行: 實做一個 Predicate 類別，測試傳入值是否大於 5。
• 第 10 行: 產生一個有 8 個數字的串流。
• 第 11 行: 利用第 8 行實做的 Predicate 類別過瀘第 10 行的串流資料，過瀘出來的資料放入一個 List。
• 第 12 行: 輸出 List 裡的值，可以看到只輸出大於 5 的元素。
• 第 17、19 行: 實做兩個 Predicate 類別，用來篩選大於 10 及小於 20 的值。
• 第 20 行: 用 greaterThanTen 搭配 Predicate 介面中的 and method 整合 lowerThanTwenty 篩選同時滿足大於 10 及小於 20 兩個條件的值。
• 第 23 行: 將第 20 行的結果透過 Predicate 介面中提供的 negate method 將值反向，所以原本是 true，反向變 false。 
上面程式第 8、17、19 宣告的是 Integer 型別，實際傳入的是 int 型別，在 Java 中執行時，會先把 int 轉型成 Integer，在效能上會比較差, 為了避免這個問題，Java 另外提供了 IntPredicate，以第 17 行來說，可以改成如下:

IntPredicate greaterThanTen = (i) -> i > 10;

這樣避免了轉型，速度會快些。


Function

@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;
    }
}

Function 的 apply method 類似於 Stream 的 map，將 T 經運算後傳出 R。

@DisplayName("FunctionTest")
@SpringBootTest
@Slf4j
class FunctionTest {
    @Test
    void apply() {
	Function<Integer, Double> half = a -> a / 2.0;
	log.debug(half.apply(10).toString());
    }
}

上面程式執行後傳回 5.0，程式說明如下:

• 第 7 行: 實傳一個 Function 類別，將傳入值除以 2 傳回。
• 第 8 行: 傳入 10，傳回 5.0。
上面程式也有轉型的問題，要避開這個問題，程式可以改成如下:

IntToDoubleFunction half = a -> a / 2.0;
log.debug(Double.toString(half.applyAsDouble(10)));