Java8新特性-四大核心函式式介面

總結一下java8中的新特性內建的四大核心函式式介面

函式式介面在java中是指:有且僅有一個抽象方法的介面

函式式介面，即適用於函數語言程式設計場景的介面。而java中的函數語言程式設計體現就是Lambda，所以函式式介面就是可以適用於Lambda使用的介面。只有確保介面中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。

@FunctionalInterface

@FunctionalInterface標註在一個介面上，說明這個介面是一個函式式介面。

那麼關於函式式介面，有如下特點：

• 有且只有一個抽象方法
• 可以有多個靜態方法
• 可以有多個default方法(預設方法)
• 可以有多個Object的public的抽象方法

消費型介面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有引數，無返回值

Consumer有兩個方法：accept()抽象方法, andThen()非抽象方法

使用示例：

//Consumer<T> 消費型介面 :
@Test
public void test1(){
    happy(10000, (m) -> System.out.println("消費：" + m + "元"));
} 

public void happy(double money, Consumer<Double> con){
    con.accept(money);
}

供給型介面Supplier:

原始碼

@FunctionalInterface
public interface Supplier<T> {
    // 無輸入引數，提供一個建立好的物件，即結果
    T get();
}

使用示例

//Supplier<T> 供給型介面 :
@Test
public void test2(){
    List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));

    for (Integer num : numList) {
        System.out.println(num);
    }
}
//需求：產生指定個數的整數，並放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
    List<Integer> list = new ArrayList<>();

    for (int i = 0; i < num; i++) {
        Integer n = sup.get();
        list.add(n);
    }

    return list;
}

函式型介面Function:

原始碼

@FunctionalInterface
public interface Function<T, R> {
    // 我給你一個引數，你幫我處理一下，給我返回另一個引數。
    R apply(T t);

    // 返回一個組合函式，首先將入參應用到before函式，再將before函式結果應用到該函式中
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    // 返回一個組合函式，該函式結果應用到after函式中
    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<T, R> 函式型介面：
@Test
public void test3(){
    String newStr = strHandler("\t\t\t 這是一個字串", (str) -> str.trim());
    System.out.println(newStr);

    String subStr = strHandler("這是一個字串", (str) -> str.substring(2, 5));
    System.out.println(subStr);
}

//需求：用於處理字串
public String strHandler(String str, Function<String, String> fun){
    return fun.apply(str);
}

斷言型介面:Predicate

原始碼：

@FunctionalInterface
public interface Predicate<T> {
    // 給一個引數T，返回boolean型別的結果
    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);
    }
}

Predicate預設實現的三個重要方法and，or和negate，這三個方法對應了java的三個連線符號&&、||和!，isEqual這個方法的返回型別也是Predicate，所以我們也可以把它作為函式式介面進行使用。我們可以當做==操作符來使用。

使用示例：

//Predicate<T> 斷言型介面：
@Test
public void test4(){
    List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
    List<String> strList = filterStr(list, (s) -> s.length() > 3);

    for (String str : strList) {
        System.out.println(str);
    }
}

//需求：將滿足條件的字串，放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
    List<String> strList = new ArrayList<>();

    for (String str : list) {
        if(pre.test(str)){
            strList.add(str);
        }
    }

    return strList;
}