常用函數式接口

常用函數式接口

JDK提供了大量常用的函數式接口以豐富Lambda的典型使用場景，它們主要在 java.util.function 包中被提供。 下面是簡單的幾個接口及使用示例。

Supplier接口

java.util.function.Supplier<T> 接口僅包含一個無參的方法： T get() 。用來獲取一個泛型參數指定類型的對 象數據。由於這是一個函數式接口，這也就意味着對應的Lambda表達式需要“對外提供”一個符合泛型類型的對象 數據

/*
    常用的函數式接口
    java.util.function.Supplier<T>接口僅包含一個無參的方法：T get()。用來獲取一個泛型參數指定類型的對象數據。

    Supplier<T>接口被稱之為生產型接口,指定接口的泛型是什么類型,那么接口中的get方法就會生產什么類型的數據
 */
public class Demo01Supplier {
    //定義一個方法,方法的參數傳遞Supplier<T>接口,泛型執行String,get方法就會返回一個String
    public static String getString(Supplier<String> sup){
        return sup.get();
        // 不要被sup.get()所迷惑，你試試return "hello world",也是可以的，不過我們要想拿到生產型接口的返回值，自然而然就是sup.get（）了，
    }

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

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

練習：求數組元素最大值

題目

使用 Supplier 接口作為方法參數類型，通過Lambda表達式求出int數組中的大值。提示：接口的泛型請使用 java.lang.Integer 類。

解答

*
    練習：求數組元素最大值
        使用Supplier接口作為方法參數類型，通過Lambda表達式求出int數組中的最大值。
        提示：接口的泛型請使用java.lang.Integer類。
 */
public class Demo02Test {
   //定義一個方法,用於獲取int類型數組中元素的最大值,方法的參數傳遞Supplier接口,泛型使用Integer
   public static int getMax(Supplier<Integer> sup){
       return sup.get();
   }

    public static void main(String[] args) {
        //定義一個int類型的數組,並賦值
        int[] arr = {100,0,-50,880,99,33,-30};
        //調用getMax方法,方法的參數Supplier是一個函數式接口,所以可以傳遞Lambda表達式
        int maxValue = getMax(()->{
            //獲取數組的最大值,並返回
            //定義一個變量,把數組中的第一個元素賦值給該變量,記錄數組中元素的最大值
            int max = arr[0];
            //遍歷數組,獲取數組中的其他元素
            for (int i : arr) {
                //使用其他的元素和最大值比較
                if(i>max){
                    //如果i大於max,則替換max作為最大值
                    max = i;
                }
            }
            //返回最大值
            return max;
        });
        System.out.println("數組中元素的最大值是:"+maxValue);
    }
}

Consumer接口

java.util.function.Consumer<T> 接口則正好與Supplier接口相反，它不是生產一個數據，而是消費一個數據， 其數據類型由泛型決定。

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意為消費一個指定泛型的數據。基本使用如：

/*
    java.util.function.Consumer<T>接口則正好與Supplier接口相反，
        它不是生產一個數據，而是消費一個數據，其數據類型由泛型決定。
    Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的數據。

   Consumer接口是一個消費型接口,泛型執行什么類型,就可以使用accept方法消費什么類型的數據
   至於具體怎么消費(使用),需要自定義(輸出,計算....)
 */
public class Demo01Consumer {
    /*
        定義一個方法
        方法的參數傳遞一個字符串的姓名
        方法的參數傳遞Consumer接口,泛型使用String
        可以使用Consumer接口消費字符串的姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

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

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

當然，更好的寫法是使用方法引用

Consumer接口中還有一個默認方法andThen

如果一個方法的參數和返回值全都是 Consumer 類型，那么就可以實現效果：消費數據的時候，首先做一個操作， 然后再做一個操作，實現組合。而這個方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代碼：

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

備注： java.util.Objects 的 requireNonNull 靜態方法將會在參數為null時主動拋出 NullPointerException 異常。這省去了重復編寫if語句和拋出空指針異常的麻煩。

下面來舉例說明用法：

import java.util.function.Consumer;

/*
   Consumer接口的默認方法andThen
   作用:需要兩個Consumer接口,可以把兩個Consumer接口組合到一起,在對數據進行消費

   例如:
    Consumer<String> con1
    Consumer<String> con2
    String s = "hello";
    con1.accept(s);
    con2.accept(s);
    連接兩個Consumer接口  再進行消費
    con1.andThen(con2).accept(s); 誰寫前邊誰先消費
*/
public class Demo02AndThen {
    //定義一個方法,方法的參數傳遞一個字符串和兩個Consumer接口,Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){
        //con1.accept(s);
        //con2.accept(s);
        //使用andThen方法,把兩個Consumer接口連接到一起,在消費數據
        con1.andThen(con2).accept(s);//con1連接con2,先執行con1消費數據,在執行con2消費數據
    }

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

輸出結果：

HELLO
hello

再舉一個例子：

package com.itheima.demo05.Consumer;

import java.util.function.Consumer;

/*
    練習:
        字符串數組當中存有多條信息，請按照格式“姓名：XX。性別：XX。”的格式將信息打印出來。
        要求將打印姓名的動作作為第一個Consumer接口的Lambda實例，
        將打印性別的動作作為第二個Consumer接口的Lambda實例，
        將兩個Consumer接口按照順序“拼接”到一起。
 */
public class Demo03Test {
    //定義一個方法,參數傳遞String類型的數組和兩個Consumer接口,泛型使用String
    public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){
        //遍歷字符串數組
        for (String message : arr) {
            //使用andThen方法連接兩個Consumer接口,消費字符串
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        //定義一個字符串類型的數組
        String[] arr = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男" };

        //調用printInfo方法,傳遞一個字符串數組,和兩個Lambda表達式
        printInfo(arr,(message)->{
            //消費方式:對message進行切割,獲取姓名,按照指定的格式輸出
            String name = message.split(",")[0];
            System.out.print("姓名: "+name);
        },(message)->{
            //消費方式:對message進行切割,獲取年齡,按照指定的格式輸出
            String age = message.split(",")[1];
            System.out.println("。年齡: "+age+"。");
        });
        
    }

}

Predicate接口

有時候我們需要對某種類型的數據進行判斷，從而得到一個boolean值結果。這時可以使用 java.util.function.Predicate<T> 接口。

抽象方法：test

import java.util.function.Predicate;
/*
    java.util.function.Predicate<T>接口
    作用:對某種數據類型的數據進行判斷,結果返回一個boolean值

    Predicate接口中包含一個抽象方法：
        boolean test(T t):用來對指定數據類型數據進行判斷的方法
            結果:
                符合條件,返回true
                不符合條件,返回false
*/
public class Demo01Predicate {
    /*
        定義一個方法
        參數傳遞一個String類型的字符串
        傳遞一個Predicate接口,泛型使用String
        使用Predicate中的方法test對字符串進行判斷,並把判斷的結果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return  pre.test(s);
    }

    public static void main(String[] args) {
        String s = "abcdef";
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}

條件判斷的標准是傳入的Lambda表達式邏輯，只要字符串長度大於5則認為很長。

默認方法：and

既然是條件判斷，就會存在與、或、非三種常見的邏輯關系。其中將兩個 Predicate 條件使用“與”邏輯連接起來實 現“並且”的效果時，可以使用default方法 and 。其JDK源碼為：

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
// 方法內部的兩個判斷條件,也是使用&&運算符連接起來的，我們平時在判斷並且這種關系時，也是用的&&

如果要判斷一個字符串既要包含大寫“H”，又要包含大寫“W”，那么：

/*
    需求:判斷一個字符串,有兩個判斷的條件
        1.判斷字符串的長度是否大於5
        2.判斷字符串中是否包含a
    兩個條件必須同時滿足,我們就可以使用&&運算符連接兩個條件
 */
public class Demo02Predicate_and {
    /*
        定義一個方法,方法的參數,傳遞一個字符串
        傳遞兩個Predicate接口
            一個用於判斷字符串的長度是否大於5
            一個用於判斷字符串中是否包含a
            兩個條件必須同時滿足
     */
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);//等價於return pre1.test(s) && pre2.test(s);
    }

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

默認方法：or

與 and 的“與”類似，默認方法 or 實現邏輯關系中的“或”。JDK源碼為：

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
// 底層用||來實現

默認方法：negate

JDK源碼：

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
// 取反，要在調用抽象方法前調用該方法

舉例：

import java.util.function.Predicate;

/*
    需求:判斷一個字符串長度是否大於5
        如果字符串的長度大於5,那返回false
        如果字符串的長度不大於5,那么返回true
    所以我們可以使用取反符號!對判斷的結果進行取反
 */
public class Demo04Predicate_negate {
    /*
           定義一個方法,方法的參數,傳遞一個字符串
           使用Predicate接口判斷字符串的長度是否大於5
    */
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return  pre.negate().test(s);//等效於return !pre.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "abc";
        //調用checkString方法,參數傳遞字符串和Lambda表達式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大於5,並返回結果
            return str.length()>5;
        });
        System.out.println(b);
    }
}

Function接口

java.util.function.Function<T,R> 接口用來根據一個類型的數據得到另一個類型的數據，前者稱為前置條件， 后者稱為后置條件

抽象方法：apply

Function 接口中主要的抽象方法為： R apply(T t) ，根據類型T的參數獲取類型R的結果。
使用的場景例如：將 String 類型轉換為 Integer 類型。

import java.util.function.Function;
/*
    java.util.function.Function<T,R>接口用來根據一個類型的數據得到另一個類型的數據，
        前者稱為前置條件，后者稱為后置條件。
    Function接口中最主要的抽象方法為：R apply(T t)，根據類型T的參數獲取類型R的結果。
        使用的場景例如：將String類型轉換為Integer類型。
 */
public class Demo01Function {
    /*
        定義一個方法
        方法的參數傳遞一個字符串類型的整數
        方法的參數傳遞一個Function接口,泛型使用<String,Integer>
        使用Function接口中的方法apply,把字符串類型的整數,轉換為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) {
        //定義一個字符串類型的整數
        String s = "1234";
        //調用change方法,傳遞字符串類型的整數,和Lambda表達式
        change(s,(String str)->{
            //把字符串類型的整數,轉換為Integer類型的整數返回
            return Integer.parseInt(str);
        });
        //優化Lambda
        change(s,str->Integer.parseInt(str));
    }
}

默認方法：andThen

舉例：

import java.util.function.Function;

/*
    Function接口中的默認方法andThen:用來進行組合操作

    需求:
        把String類型的"123",轉換為Inteter類型,把轉換后的結果加10
        把增加之后的Integer類型的數據,轉換為String類型

    分析:
        轉換了兩次
        第一次是把String類型轉換為了Integer類型
            所以我們可以使用Function<String,Integer> fun1
                Integer i = fun1.apply("123")+10;
        第二次是把Integer類型轉換為String類型
            所以我們可以使用Function<Integer,String> fun2
                String s = fun2.apply(i);
        我們可以使用andThen方法,把兩次轉換組合在一起使用
            String s = fun1.andThen(fun2).apply("123");
            fun1先調用apply方法,把字符串轉換為Integer
            fun2再調用apply方法,把Integer轉換為字符串
 */
public class Demo02Function_andThen {
    /*
        定義一個方法
        參數串一個字符串類型的整數
        參數再傳遞兩個Function接口
            一個泛型使用Function<String,Integer>
            一個泛型使用Function<Integer,String>
     */
    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) {
        //定義一個字符串類型的整數
        String s = "123";
        //調用change方法,傳遞字符串和兩個Lambda表達式
        change(s,(String str)->{
            //把字符串轉換為整數+10
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            //把整數轉換為字符串
            return i+"";
        });

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