JUC并發程式設計學習（十二）-四大函數式接口

函數式接口

有且隻有一個抽象方法的接口。

函數式接口，即适用于函數式程式設計場景的接口。而java中的函數式程式設計展現就是Lambda,是以函數式接口就是可以适用于Lambda使用的接口。隻要確定接口中有且隻有一個抽象方法，而java中的Lambda才能順利進行推導。

格式

隻要確定接口中有且僅有一個抽象方法即可：

修飾符 interface 接口名稱{
        public abstract 傳回值類型  方法名稱（可選參數資訊）；
        //其他非抽象方法内容
}

由于接口當中抽象方法 public abstract是可以被省略的，是以定義一個函數式接口很簡單：

public interface MyFunctionInterface{
    void myMethod();
}

@FunctionalInterface注解

與 @Override 注解的作用類似，Java 8中專門為函數式接口引入了一個新的注解： @FunctionalInterface 。該注解可用于一個接口的定義上：

@FunctionalInterface
public interface MyFunctionInterface{
    void myMethod();
}

一旦使用該注解來定義接口，編譯器将會被強制檢查該接口是否确實有且僅有一個抽象方法，否則将會報錯。需要注意的是，即使不使用此注解，隻要滿足函數式接口的定義，這仍然是一個函數式接口，使用起來都一樣。

自定義函數式接口

對于剛剛定義好的 MyFunctionalInterface 函數式接口，典型使用場景就是作為方法的參數：

package com.demo.java.study7;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 13:48
* @description:
* @Version: 1.0
*/
public class Test {


    // 使用自定義的函數式接口作為方法參數
    public static void doSomeThing(MyFunctionInterface my){
        my.myMethod();// 調用自定義的函數式接口方法
    }


    public static void main(String[] args) {
        //調用函數式接口的方法
        doSomeThing(()->{
            System.out.println("Lambda執行了");
        });
    }
}

執行結果

JUC并發程式設計學習（十二）-四大函數式接口

四大函數式接口

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

JUC并發程式設計學習（十二）-四大函數式接口

下面是最簡單的幾個接口及使用示例。

Supplier接口

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

import java.util.function.Supplier;


/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 14:51
* @description:
* @Version: 1.0
*/
public class Test5 {

    private static String getString(Supplier<String> supplier){
        return supplier.get();
    }

    public static void main(String[] args) {

        String msgA="hello";
        String msgB="world";
        String msgC="java";
        System.out.println(getString(()->msgA+msgB+msgC));
    }

}

練習：求數組元素最大值

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

import java.util.function.Supplier;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 14:55
* @description:
* @Version: 1.0
*/
public class Test6 {


    /**
     * @Param [supplier]
     * @return java.lang.Integer
     * @Author youjp
     * @Description //TODO 擷取最大數
     * @throw
     **/
    private static Integer getMax(Supplier<Integer> supplier) {
        return supplier.get();
    }


    public static void main(String[] args) {
        int arr[] = {2, 3, 44, 55, 8};


        int maxNum = getMax(() -> {
            int max = 0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] >= max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxNum);
    }
}

Consumer接口

java.util.function.Consumer 接口則正好與Supplier接口相反，它不是生産一個資料，而是消費一個資料，其資料類型由泛型決定。

抽象方法：accept

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

import java.util.function.Consumer;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 15:22
* @description:
* @Version: 1.0
*/
public class Test7 {
    private static void consumeString(Consumer<String> function){
            function.accept("hello");
    }
    public static void main(String[] args) {
        consumeString(s -> System.out.println(s));
    }
}

執行結果

JUC并發程式設計學習（十二）-四大函數式接口

預設方法：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語句和抛出空指針異常的麻煩。

要想實作組合，需要兩個或多個Lambda表達式即可，而 andThen 的語義正是“一步接一步”操作。例如兩個步驟組合的情況：

package com.demo.java.study7;
import java.util.function.Consumer;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 15:22
* @description:
* @Version: 1.0
*/
public class Test7 {
    private static void consumeString(Consumer<String> one,Consumer<String> two){
        one.andThen(two).accept("Hello");
    }


    public static void main(String[] args) {
			//先轉大寫字母，再轉小寫字母
        consumeString(
                s -> System.out.println(s.toUpperCase()),
                s-> System.out.println(s.toLowerCase()));
    }
}

運作結果将會首先列印完全大寫的HELLO，然後列印完全小寫的hello。當然，通過鍊式寫法可以實作更多步驟的組合。

JUC并發程式設計學習（十二）-四大函數式接口

練習：格式化列印資訊

下面的字元串數組當中存有多條資訊，請按照格式“ 姓名：XX。性别：XX。 ”的格式将資訊列印出來。要求将列印姓名的動作作為第一個 Consumer 接口的Lambda執行個體，将列印性别的動作作為第二個 Consumer 接口的Lambda執行個體，将兩個 Consumer 接口按照順序“拼接”到一起。

public static void main(String[] args) {
String[] array = { "迪麗熱巴,女", "古力娜紮,女", "馬爾紮哈,男" };
}

解答

import java.util.function.Consumer;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 15:53
* @description:
* @Version: 1.0
*/
public class Test8 {

    private static void consumeString(Consumer<String> one,Consumer<String> two,String[] array){
        for(String info:array){
            one.andThen(two).accept(info);
        }
    }
    public static void main(String[] args) {
        String[] array = { "迪麗熱巴,女", "古力娜紮,女", "馬爾紮哈,男" };
        consumeString(
                s-> System.out.print("姓名："+s.split(",")[0]),
                s -> System.out.println(" 性别："+s.split(",")[1]+"。"),array);
    }
}

輸出：

JUC并發程式設計學習（十二）-四大函數式接口

Predicate接口

有時候我們需要對某種類型的資料進行判斷，進而得到一個boolean值結果。這時可以使用

java.util.function.Predicate 接口。

抽象方法：test

Predicate 接口中包含一個抽象方法： boolean test(T t) 。用于條件判斷的場景：

import java.util.function.Predicate;
public class Demo15PredicateTest {
    private static void method(Predicate<String> predicate) {
    boolean veryLong = predicate.test("HelloWorld");
    System.out.println("字元串很長嗎：" + veryLong);
    }

    public static void main(String[] args) {
    method(s ‐> s.length() > 5);
    }
}

條件判斷的标準是傳入的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”，那麼：

import java.util.function.Predicate;
    public class Demo16PredicateAnd {
        private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.and(two).test("Helloworld");
        System.out.println("字元串符合要求嗎：" + isValid);
    }

    public static void main(String[] args) {
    method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

預設方法：or

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

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) || other.test(t);
}

如果希望實作邏輯“字元串包含大寫H或者包含大寫W”，那麼代碼隻需要将“and”修改為“or”名稱即可，其他都不變:

import java.util.function.Predicate;
public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.or(two).test("Helloworld");
        System.out.println("字元串符合要求嗎：" + isValid);
    }

    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

預設方法：negate

與”、“或”已經了解了，剩下的“非”（取反）也會簡單。預設方法 negate 的JDK源代碼為：

default Predicate<T> negate() {
return (t) ‐> !test(t);
}

從實作中很容易看出，它是執行了test方法之後，對結果boolean值進行“!”取反而已。一定要在 test 方法調用之前調用 negate 方法，正如 and 和 or 方法一樣：

import java.util.function.Predicate;
public class Demo17PredicateNegate {
    private static void method(Predicate<String> predicate) {
        boolean veryLong = predicate.negate().test("HelloWorld");
        System.out.println("字元串很長嗎：" + veryLong);
    }

    public static void main(String[] args) {
        method(s ‐> s.length() < 5);
    }
}

練習：集合資訊篩選 ** 比較常用

數組當中有多條“姓名+性别”的資訊如下，請通過 Predicate 接口的拼裝将符合要求的字元串篩選到集合ArrayList 中，需要同時滿足兩個條件：

必須為女生；
姓名為4個字。

public class DemoPredicate {
    public static void main(String[] args) {
        String[] array = { "迪麗熱巴,女", "古力娜紮,女", "馬爾紮哈,男", "趙麗穎,女" };
    }
}

解答

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;


/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 19:47
* @description:
* @Version: 1.0
*/
public class Test9 {

    public static void main(String[] args) {
        String[] array = { "迪麗熱巴,女", "古力娜紮,女", "馬爾紮哈,男", "趙麗穎,女" };

       List<String> list= filter(s -> "女".equals(s.split(",")[1]),
                s -> s.split(",")[0].length()==4
                ,array);
        System.out.println(list);
    }

    private static List<String> filter(Predicate<String> one,Predicate<String> two,String[] array){
        List<String> list=new ArrayList<>();
        for(int i=0;i<array.length;i++){
            if(one.and(two).test(array[i])){
                list.add(array[i]);
            }
        }
        return  list;
    }
}

執行結果：

JUC并發程式設計學習（十二）-四大函數式接口

Function接口

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

抽象方法：apply

Function 接口中最主要的抽象方法為： R apply(T t) ，根據類型T的參數擷取類型R的結果。

使用的場景例如：将 String 類型轉換為 Integer 類型。

import java.util.function.Function;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 20:17
* @description:
* @Version: 1.0
*/
public class Test10 {


    private static void method(Function<String,Integer> function){
        int num=function.apply("10");
        System.out.println(num+5);
    }


    public static void main(String[] args) {
        method(s -> Integer.parseInt(s));
    }
}

輸出結果為15。

預設方法：andThen

Function 接口中有一個預設的 andThen 方法，用來進行組合操作。JDK源代碼如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

該方法同樣用于“先做什麼，再做什麼”的場景，和 Consumer 中的 andThen 差不多：

import java.util.function.Function;
/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 20:17
* @description:
* @Version: 1.0
*/
public class Test10 {


    private static void method(Function<String,Integer> one,Function<Integer,Integer> two){
        int num=one.andThen(two).apply("10");   //10*10=100
        System.out.println(num+5);  //100+5=105
    }


    public static void main(String[] args) {
      method(s -> Integer.parseInt(s), s->s*=10);   //先轉換為數字，再乘以10
    }
}

第一個操作是将字元串解析成為int數字，第二個操作是乘以10。兩個操作通過 andThen 按照前後順序組合到了一起。

請注意，Function的前置條件泛型和後置條件泛型可以相同。

練習：自定義函數模型拼接

請使用 Function 進行函數模型的拼接，按照順序需要執行的多個函數操作為：

String str = “趙麗穎,20”;

将字元串截取數字年齡部分，得到字元串；
将上一步的字元串轉換成為int類型的數字；
将上一步的int數字累加100，得到結果int數字。

import java.util.function.Function;


/**
* @ClassName:
* @PackageName: com.demo.java.study7
* @author: youjp
* @create: 2020-02-15 20:17
* @description:
* @Version: 1.0
*/
public class Test10 {


    private static void method(Function<String,String> one,Function<String,Integer> two,Function<Integer,Integer> three,String s){
        int num=one.andThen(two).andThen(three).apply(s);
        System.out.println(num);
    }


    public static void main(String[] args) {
        String str = "趙麗穎,20";


        //1. 将字元串截取數字年齡部分，得到字元串；
        // 2. 将上一步的字元串轉換成為int類型的數字；
        // 3. 将上一步的int數字累加100，得到結果int數字。
        method(s -> s.split(",")[1] ,
                s -> Integer.parseInt(s),
                s->s+=100,
                str
          );
    }
}

執行結果：

JUC并發程式設計學習（十二）-四大函數式接口

JUC并發程式設計學習（十二）-四大函數式接口

函數式接口

@FunctionalInterface注解

自定義函數式接口

四大函數式接口

Supplier接口

Consumer接口

Predicate接口

Function接口

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method