常用函數(shù)式接口

JDK提供了大量常用的函數(shù)式接口以豐富Lambda的典型使用場景，它們主要在 java.util.function 包中被提供。

Supplier接口

java.util.function.Supplier<T>接口僅包含一個無參的方法：

• T get()。用來獲取一個泛型參數(shù)指定類型的對象數(shù)據(jù)。

Supplier<T>接口被稱之為生產(chǎn)型接口,指定接口的泛型是什么類型,那么接口中的get方法就會生產(chǎn)什么類型的數(shù)據(jù)

//定義一個方法,方法的參數(shù)傳遞Supplier<T>接口,泛型執(zhí)行String,get方法就會返回一個String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //調(diào)用getString方法,方法的參數(shù)Supplier是一個函數(shù)式接口,所以可以傳遞Lambda表達(dá)式
        String s = getString(()->{
            //生產(chǎn)一個字符串,并返回
            return "胡歌";
        });
        System.out.println(s);

        //優(yōu)化Lambda表達(dá)式
        String s2 = getString(()->"胡歌");
        System.out.println(s2);
    }

Consumer接口

java.util.function.Consumer<T>接口則正好與Supplier接口相反，
它不是生產(chǎn)一個數(shù)據(jù)，而是消費一個數(shù)據(jù)，其數(shù)據(jù)類型由泛型決定。
抽象方法：accept：
Consumer接口中包含抽象方法:

• void accept(T t)，意為消費一個指定泛型的數(shù)據(jù)。

Consumer<T>接口是一個消費型接口,泛型執(zhí)行什么類型,就可以使用accept方法消費什么類型的數(shù)據(jù)
至于具體怎么消費(使用),需要自定義(輸出,計算....)

        定義一個方法
        方法的參數(shù)傳遞一個字符串的姓名
        方法的參數(shù)傳遞Consumer接口,泛型使用String
        可以使用Consumer接口消費字符串的姓名
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        //調(diào)用method方法,傳遞字符串姓名,方法的另一個參數(shù)是Consumer接口,是一個函數(shù)式接口,所以可以傳遞Lambda表達(dá)式
        method("趙麗穎",(String name)->{
            //對傳遞的字符串進(jìn)行消費
            //消費方式:直接輸出字符串
            //System.out.println(name);

            //消費方式:把字符串進(jìn)行反轉(zhuǎn)輸出
            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }

默認(rèn)方法：andThen：
Consumer接口的默認(rèn)方法andThen
作用:需要兩個Consumer接口,可以把兩個Consumer接口組合到一起,再對數(shù)據(jù)進(jìn)行消費
例如:
Consumer<String> con1
Consumer<String> con2
String s = "hello";
con1.accept(s);
con2.accept(s);
連接兩個Consumer接口 再進(jìn)行消費
con1.andThen(con2).accept(s); 誰寫前邊誰先消費

//定義一個方法,方法的參數(shù)傳遞一個字符串和兩個Consumer接口,Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){
        //使用andThen方法,把兩個Consumer接口連接到一起,在消費數(shù)據(jù)
        con1.andThen(con2).accept(s);//con1連接con2,先執(zhí)行con1消費數(shù)據(jù),在執(zhí)行con2消費數(shù)據(jù)
    }

    public static void main(String[] args) {
        //調(diào)用method方法,傳遞一個字符串,兩個Lambda表達(dá)式
        method("Hello",
                (t)->{
                    //消費方式:把字符串轉(zhuǎn)換為大寫輸出
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    //消費方式:把字符串轉(zhuǎn)換為小寫輸出
                    System.out.println(t.toLowerCase());
                });
    }

Predicate接口

java.util.function.Predicate<T>接口
作用:對某種數(shù)據(jù)類型的數(shù)據(jù)進(jìn)行判斷,結(jié)果返回一個boolean值
抽象方法：test
Predicate接口中包含一個抽象方法：

• boolean test(T t):用來對指定數(shù)據(jù)類型數(shù)據(jù)進(jìn)行判斷的方法

結(jié)果:
符合條件,返回true
不符合條件,返回false

        定義一個方法
        參數(shù)傳遞一個String類型的字符串
        傳遞一個Predicate接口,泛型使用String
        使用Predicate中的方法test對字符串進(jìn)行判斷,并把判斷的結(jié)果返回
    public static boolean checkString(String s, Predicate<String> pre){
        return  pre.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "abcdef";

        //調(diào)用checkString方法對字符串進(jìn)行校驗,參數(shù)傳遞字符串和Lambda表達(dá)式
        boolean b = checkString(s,(String str)->{
            //對參數(shù)傳遞的字符串進(jìn)行判斷,判斷字符串的長度是否大于5,并把判斷的結(jié)果返回
            return str.length()>5;
        });

        //優(yōu)化Lambda表達(dá)式
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }

默認(rèn)方法：and
邏輯表達(dá)式:可以連接多個判斷的條件
&&:與運算符,有false則false(and方法)
||:或運算符,有true則true(or方法)
!:非(取反)運算符,非真則假,非假則真(negate方法)

需求:判斷一個字符串,有兩個判斷的條件
1.判斷字符串的長度是否大于5
2.判斷字符串中是否包含a
兩個條件必須同時滿足,我們就可以使用&&運算符連接兩個條件

Predicate接口中有一個方法and,表示并且關(guān)系,也可以用于連接兩個判斷條件
方法(源碼)內(nèi)部的兩個判斷條件,也是使用&&運算符連接起來的

public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(s);//等價于return pre1.test(s) && pre2.test(s);
    }
    public static void main(String[] args) {
        //定義一個字符串
        String s = "abcdef";
        //調(diào)用checkString方法,參數(shù)傳遞字符串和兩個Lambda表達(dá)式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大于5
            return str.length()>5;
        },(String str)->{
            //判斷字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }

默認(rèn)方法：or
需求:判斷一個字符串,有兩個判斷的條件
1.判斷字符串的長度是否大于5
2.判斷字符串中是否包含a
滿足一個條件即可,我們就可以使用||運算符連接兩個條件

Predicate接口中有一個方法or,表示或者關(guān)系,也可以用于連接兩個判斷條件
方法內(nèi)部的兩個判斷條件,也是使用||運算符連接起來的

public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        return  pre1.or(pre2).test(s);//等價于return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "bc";
        //調(diào)用checkString方法,參數(shù)傳遞字符串和兩個Lambda表達(dá)式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大于5
            return str.length()>5;
        },(String str)->{
            //判斷字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }

默認(rèn)方法：negate
需求:判斷一個字符串長度是否大于5
如果字符串的長度大于5,那返回false
如果字符串的長度不大于5,那么返回true
所以我們可以使用取反符號!對判斷的結(jié)果進(jìn)行取反

Predicate接口中有一個方法negate,也表示取反的意思

public static boolean checkString(String s, Predicate<String> pre){
        return  pre.negate().test(s);//等效于return !pre.test(s);
    }
    public static void main(String[] args) {
        //定義一個字符串
        String s = "abc";
        //調(diào)用checkString方法,參數(shù)傳遞字符串和Lambda表達(dá)式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大于5,并返回結(jié)果
            return str.length()>5;
        });
        System.out.println(b);
    }

Function接口

java.util.function.Function<T,R>接口用來根據(jù)一個類型的數(shù)據(jù)得到另一個類型的數(shù)據(jù)，
前者稱為前置條件，后者稱為后置條件。
抽象方法：apply
Function接口中最主要的抽象方法為：

• R apply(T t)，根據(jù)類型T的參數(shù)獲取類型R的結(jié)果。
  使用的場景例如：將String類型轉(zhuǎn)換為Integer類型。

public static void change(String s, Function<String,Integer> fun){
        //Integer in = fun.apply(s);
        int in = fun.apply(s);//自動拆箱 Integer->int
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定義一個字符串類型的整數(shù)
        String s = "1234";
        //調(diào)用change方法,傳遞字符串類型的整數(shù),和Lambda表達(dá)式
        change(s,(String str)->{
            //把字符串類型的整數(shù),轉(zhuǎn)換為Integer類型的整數(shù)返回
            return Integer.valueOf(str);//valueOf方法：返回一個表示指定的 int 值的 Integer 實例。
        });
        //優(yōu)化Lambda
        change(s,str->Integer.parseInt(str));

默認(rèn)方法：andThen
Function接口中的默認(rèn)方法andThen:用來進(jìn)行組合操作

需求:
把String類型的"123",轉(zhuǎn)換為Inteter類型,把轉(zhuǎn)換后的結(jié)果加10
把增加之后的Integer類型的數(shù)據(jù),轉(zhuǎn)換為String類型

分析:
轉(zhuǎn)換了兩次
第一次是把String類型轉(zhuǎn)換為了Integer類型
所以我們可以使用Function<String,Integer> fun1
Integer i = fun1.apply("123")+10;

第二次是把Integer類型轉(zhuǎn)換為String類型
所以我們可以使用Function<Integer,String> fun2
String s = fun2.apply(i);

我們可以使用andThen方法,把兩次轉(zhuǎn)換組合在一起使用
String s = fun1.andThen(fun2).apply("123");
fun1先調(diào)用apply方法,把字符串轉(zhuǎn)換為Integer
fun2再調(diào)用apply方法,把Integer轉(zhuǎn)換為字符串

public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        //定義一個字符串類型的整數(shù)
        String s = "123";
        //調(diào)用change方法,傳遞字符串和兩個Lambda表達(dá)式
        change(s,(String str)->{
            //把字符串轉(zhuǎn)換為整數(shù)+10
            return Integer.parseInt(str)+10;//parseInt方法：將字符串參數(shù)作為有符號的十進(jìn)制整數(shù)進(jìn)行解析。
        },(Integer i)->{
            //把整數(shù)轉(zhuǎn)換為字符串
            return i+"";
        });

        //優(yōu)化Lambda表達(dá)式
        change(s,str->Integer.parseInt(str)+10,i->i+"");
    }