您有任何問題或意見都可以在評論區回覆哦，歡迎大家一起來討論，共同學習進步

java.util.function包中有43個function interface，但是實際上只有四大類：
Consumers消費者
Supplier供應商
Functions功能
Predicates謂詞

1.Consumers一個對象，BiConsumer兩個對象

實際都是對傳入的T實體進行操作處理

public interface Consumer<T> {
    public void accept(T var1);
}

Consumer<String> printer = s-> System.out.println(s);
//或者
Consumer<String> printer = System.out::println;

public interface BiConsumer<T, U> {
    void accept(T var1, U var2);
}

2.Supplier返回類型T的對象，沒有任何入參

實際是創建了T實體並返回的操作

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

Supplier<BankAccount> bankAccountSupplier = ()->new BankAccount();
//或者
Supplier<BankAccount> bankAccountSupplier = BankAccount::new;

3.Function

實際上是對類型T實體進行相應的操作並返回類型為R的實體

public interface Function<T, R> {
    R apply(T var1);
}
Function<BankAccount, Integer> amtFunction = bankAccount -> bankAccount.getBalance();
//或者
Function<BankAccount, Integer> amtFunction = BankAccount::getBalance;

4.Predicate

確定實體T是否滿足約束，返回boolean

public interface Predicate<T> {
    boolean test(T t);
}
Predicate<BankAccount> test = bankAccount -> bankAccount.getBalance()>10;

//自定義
Predicate<String> p = new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return s.length()<20;
    }
};

p = s -> s.length()<20;
System.out.println(p.test("Hello 12321321321321312321321"));

5.還有一些其他的類型

intPredicate，intFunction，intConsumer，入參需要指定為int
以及intToDoubleFunction，入參為int，返回參數為double

public interface IntFunction<R> {
    R apply(int value);
}
public interface LongToDoubleFunction {
    double applyAsDouble(long value);
}

可以自定義Predicate接口，標準驗證以及自定義方法，靜態方法等

@FunctionalInterface
public interface Predicate<T> {
    public boolean test(T t);
    public default Predicate<T> and(Predicate<T> other){
        return t -> test(t) && other.test(t);
    }
    public default Predicate<T> or(Predicate<T> other){
        return t -> test(t) || other.test(t);
    }
    //靜態方法第一種
    public static Predicate<String> isEqualsTo(String string){
        return s -> s.equals(string);
    }
    //還可以寫成另一種
    public static <U> Predicate<U> isEqualsTo(U u){
        return s -> s.equals(u);
    }
}
public class Main {
    public static void main(String[] args) {
        Predicate<String> p1 = s -> s.length()<20;
        Predicate<String> p2 = s -> s.length()>5;
        boolean b= p1.test("Hello");
        System.out.println("Hello is shorter than 20 chars is :"+b);
輸出：
Hello is shorter than 20 chars is :true
        Predicate<String> p3 = p1.and(p2);
        System.out.println("p3 test 123 :"+p3.test("123"));
        System.out.println("p3 test 123456 :"+p3.test("123456"));
        System.out.println("p3 test 123456789012345678901 :"+p3.test("123456789012345678901"));
輸出：
p3 test 123 :false
p3 test 123456 :true
p3 test 123456789012345678901 :false
        Predicate<String> p4 = p1.or(p2);
        System.out.println("p4 test 123 :"+p4.test("123"));
        System.out.println("p4 test 123456 :"+p4.test("123456"));
        System.out.println("p4 test 123456789012345678901 :"+p4.test("123456789012345678901"));
輸出：
p4 test 123 :true
p4 test 123456 :true
p4 test 123456789012345678901 :true
        Predicate<String> p5 = Predicate.isEqualsTo("YES");
        System.out.println("p5 test YES :"+p5.test("YES"));
        System.out.println("p5 test NO :"+p5.test("NO"));
輸出：
p5 test YES :true
p5 test NO :false
    }
}