函式式編程：Lambda 運算式

在這里插入圖片描述

每博一文案

曾經讀過的依然令我感動的句子，生活總是不如意，但往往是在無數痛苦中，但往往是在無數痛苦中，在重重矛盾

和艱難中才能成熟起來，堅強起來，愛情啊，它使荒蕪變成繁榮，平庸變得偉大，使死去的復活，活著的閃閃發光，

即使愛情是不盡的煎熬折磨，像冰霜般嚴厲，烈火般烤灼，但愛情對心和身體健男女是那樣的自然，同時又永遠讓我們感到新奇神秘和不可思議....... ，生活中真正的勇士向來默默無聞，喧嘩不止的永遠是自視高貴的一群，無論精神是多么獨立，感情卻總是在尋找以一種依附，尋找一種歸宿，親人之間的感情是多么重要，假如沒有這種感情，我們活在這個世界是多么悲哀啊，只有勞動才能使人在

生活中強大，不論什么人，最侄訓是要崇尚哪些用雙手創造生活的財富者，人們寧愿關心一個蹩腳的電影演，

? —————— 《平凡的世界》路遙

函式式編程：Lambda 運算式
- 每博一文案
- 1. 函式式編程
- 2. Lambda 運算式概述
- 3. Lambda 運算式的六種語法格式
  - 3.1 第一種：無參，無回傳值，一條執行陳述句
  - 3.2 第二種：有引數，無回傳值，一條陳述句
  - 3.3 第三種：有引數，引數的資料型別可以省略，型別推斷
  - 3.4 第四種：只有一個引數，無回傳值，一條陳述句
  - 3.5 第五種：有多個引數，多條陳述句，有回傳值
  - 3.6 第六種：有多個引數，有回傳值，一條陳述句
  - 3.7 Lambda 運算式六種語法格式總結：
  - 3.8 補充：作為引數傳遞 Lambda 運算式
- 4. 函式式介面的概述
  - 4.1 自定義函式式介面
- 5. Java 內置四大核心函式式介面
  - 5.1 Consumer
  - 5.2 Supplier
  - 5.3 Function
  - 5.4 Predicate
  - 5.5 其他的函式式介面
- 6. 方法參考
  - 6.1 情況1：物件::實體方法名
  - 6.2 情況2：類::靜態方法
  - 6.3 情況3：類::實體方法
- 7. 構造器參考
- 8. 陣列參考
- 9. Lambda 運算式的優缺點：
- 10. 總結:
- 11. 最后：

1. 函式式編程

我們先看看什么是函式，函式是一種最基本的任務，一個大型程式就是一個頂層函式呼叫若干底層函式，這些被呼叫的函式又可以呼叫其他函式，即大任務被一層層拆解并執行，所以函式就是面向程序的程式設計的基本單元，

Java不支持單獨定義函式，但可以把靜態方法視為獨立的函式，把實體方法視為自帶this引數的函式，

而函式式編程（請注意多了一個“式”字）——Functional Programming，雖然也可以歸結到面向程序的程式設計，但其思想更接近數學計算，

我們首先要搞明白計算機（Computer）和計算（Compute）的概念，

在計算機的層次上，CPU執行的是加減乘除的指令代碼，以及各種條件判斷和跳轉指令，所以，匯編語言是最貼近計算機的語言，

而計算則指數學意義上的計算，越是抽象的計算，離計算機硬體越遠，

對應到編程語言，就是越低級的語言，越貼近計算機，抽象程度低，執行效率高，比如C語言；越高級的語言，越貼近計算，抽象程度高，執行效率低，比如Lisp語言，

函式式編程就是一種抽象程度很高的編程范式，純粹的函式式編程語言撰寫的函式沒有變數，因此，任意一個函式，只要輸入是確定的，輸出就是確定的，這種純函式我們稱之為沒有副作用，而允許使用變數的程式設計語言，由于函式內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函式是有副作用的，

函式式編程的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許回傳一個函式！

函式式編程最早是數學家阿隆佐·邱奇研究的一套函式變換邏輯，又稱Lambda Calculus（λ-Calculus），所以也經常把函式式編程稱為Lambda計算，

Java平臺從Java 8開始，支持函式式編程，

2. Lambda 運算式概述

相信大家一定在相關的框架的原始碼中看到不少使用了 lambda 運算式的內容吧，如果我們想要閱讀框架的原始碼上的邏輯，則必須了解，明白 Lambda 運算式的格式，語法了，

Java Lambda 運算式是 Java8 的新特性，Java lambda 運算式是 Java進入函式式編程的第一步，因此，Java lambda 運算式時可以單獨創建的，而無需屬于任何類，這一點很重要，Java Lambda 運算式可以像物件一樣傳遞并按需執行，

Java lambda 運算式通常用于實作簡單的事件監聽/回呼，或在 Java Streams API 函式式編程時使用，

Lambda 是一個匿名函式 ，我們可以把 Lambda 運算式理解為是 一段可以傳遞的代碼 （將代碼像資料一樣進行傳遞），使用它可以寫出更簡潔，更靈活的代碼，作為一種更緊湊的代碼風格，使Java 語言表達能力得到了提升，

Lambda 運算式的本質：就是作為介面的實體，簡單的說就是對匿名實作介面的替換， 因為Java當中的介面是不能 new 的，想要 new 的用該介面的話，就只能 new 該介面的實作類了，或者匿名實作介面，記住這個概念，只要你理解了這句話，那 Lambda 就十分簡單了，

如下簡單的舉例：

如下是不使用 Lambda 運算式的方式，而是簡單的匿名實作介面的方式，處理的

package blogs.blog13;

public class LambdaTest01 {
    public static void main(String[] args) {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                System.out.println("你好世界");
            }
        };

        run.run();
    }
}

在這里插入圖片描述

同樣的結果，使用 Lambda 運算式處理，

package blogs.blog13;

public class LambdaTest01 {

    public static void main(String[] args) {
        Runnable runnable = ()->System.out.println("你好世界");
        
        runnable.run();
    }
}

在這里插入圖片描述

從上述兩個使用同樣的功能，但是使用 Lambda 運算式解決的代碼量更少一些，

3. Lambda 運算式的六種語法格式

Lambda 運算式：在 Java 8 語言中引入的一種新的語法元素和運算子，這個運算子為 -> 一杠 + 一個左箭頭，該運算子被稱為 Lambda 運算子 或 箭頭運算子 ，它將 Lamdba 分為兩個部分，

箭頭左側 ：指定了 Lambda 運算式需要的引數串列 ，其實就是對應介面中的重寫抽象方法中的引數串列，

箭頭右側 ：指定了 Lambda 體，即為 Lambda 運算式要執行的功能，其實就是對應介面中共重寫抽象方法中的所要執行的陳述句/處理的邏輯，

一般的具體格式如下：

Runnable runnable = ()->System.out.println("你好世界");
                    ()-> { lambda 體所要執行的陳述句}

我們知道 Lambda 運算式的本質就是：介面的實體化，匿名實作介面的替換 ，既然要實作介面，自然也就要重寫其介面的抽象方法了，不同的介面中的抽象方法其結構也是不一樣的，既然抽象方法都不一樣了，那對應的介面中的 Lambda 運算式也有所不同了，

具體可以分為如下六種對應不同介面中的抽象方法中的不同的 Lambda 運算式的語法格式

這里我們會通過實作同樣的功能，使用 匿名實作介面 與 Lambda 運算式進行處理，兩者之間進行一個對比，這樣更容易理解 Lambda 運算式，

3.1 第一種：無參，無回傳值，一條執行陳述句

情況1： 介面中的只有一個抽象方法，該抽象方法中：無引數，無回傳值，只有一條陳述句，

Lambda 運算式的語法格式如下：

() -> 要執行的陳述句 // 一條陳述句 {} 可以省略

補充： Runable 介面的原始碼：

在這里插入圖片描述

匿名實作介面的方式：

package blogs.blog13;

public class LambdaTest01 {
    public static void main(String[] args) {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                System.out.println("你好世界");
            }
        };

        run.run();
    }
}

在這里插入圖片描述

Lambda 運算式的方式：

package blogs.blog13;

public class LambdaTest01 {

    public static void main(String[] args) {
        Runnable runnable = ()->System.out.println("你好世界");
        // () 引數串列：重寫介面中抽象方法的
        //System.out.println("你好世界"): 重寫介面中抽象方法的中執行的陳述句
        runnable.run();
    }
}

在這里插入圖片描述

3.2 第二種：有引數，無回傳值，一條陳述句

情況2： 一個介面中只有一個抽象方法，該抽象方法：有引數，無回傳值，只有一條陳述句，

Lambda 運算式的語法格式如下：

Consumer<String> consumer = (String s)-> System.out.println(s);
(引數的資料型別 引數名，引數的資料型別，引數名)-> 執行的陳述句;

補充： Consumer 介面的原始碼
在這里插入圖片描述

匿名實作介面的方式：


import java.util.function.Consumer;

public class LambdaTest01 {
    public static void main(String[] args) {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        
        consumer.accept("你好");  // 呼叫介面中重寫的抽象方法
    }
}

在這里插入圖片描述

Lambda運算式的方式：

import java.util.function.Consumer;

public class LambdaTest01 {
    public static void main(String[] args) {
        Consumer<String> consumer = (String s)-> System.out.println(s);
        consumer.accept("你好");  // 呼叫介面中重寫的抽象方法
    }
}

在這里插入圖片描述

3.3 第三種：有引數，引數的資料型別可以省略，型別推斷

情況3： 介面中的抽象方法有引數，但是該引數的資料型別可以省略不寫（你也可以寫上），Java自動會自動型別的推斷，與泛型，陣列中的型別推斷類似的，

Lambda 運算式的語法格式如下：

Consumer<String> consumer = (s)-> System.out.println(s); // 資料型別可以省略，該資料型別Java會自行推斷出來，
(引數名)-> 執行的陳述句;

匿名實作介面的方式：

import java.util.function.Consumer;

public class LambdaTest01 {
    public static void main(String[] args) {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        
        consumer.accept("你好");  // 呼叫介面中重寫的抽象方法
    }
}

在這里插入圖片描述

Lambda運算式的方式：

import java.util.function.Consumer;

public class LambdaTest01 {
    public static void main(String[] args) {
        Consumer<String> consumer = (s)-> System.out.println(s);
        consumer.accept("你好");  // 呼叫介面中重寫的抽象方法
    }
}

在這里插入圖片描述

3.4 第四種：只有一個引數，無回傳值，一條陳述句

情況4： 介面中的抽象方法：只有一個引數，無回傳值，一條陳述句，

Lambda 運算式的語法格式如下：

Consumer<String> consumer = s-> System.out.println(s); //資料型別可以省略(Java自動推斷出來)，一個引數 () 圓括號可以省略，一條陳述句{} 可以省略
引數-> 執行的陳述句

Lambda運算式的方式：

import java.util.function.Consumer;

public class LambdaTest01 {
    public static void main(String[] args) {
        Consumer<String> consumer = s-> System.out.println(s);
        consumer.accept("你好");  // 呼叫介面中重寫的抽象方法
    }
}

在這里插入圖片描述

3.5 第五種：有多個引數，多條陳述句，有回傳值

情況5： 介面中的抽象方法：有多個引數，多條陳述句，有回傳值，

Lambda 運算式的語法格式如下：

Comparator<Integer> comparator = (o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
/* (引數名，引數名) -> {
	 執行的多條陳述句;
	 執行的多條陳述句;
	 return  回傳值;
}  引數型別可以省略Java自行推斷出來，多條陳述句使用{} 花括號括起來， return 回傳值，
*/
        // 或者
        Comparator<Integer> comparator1 = (o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return Integer.compare(o1,o2);
        };

補充： Comparator 部分原始碼

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

匿名實作介面的方式：



import java.util.Comparator;

public class LambdaTest01 {
    public static void main(String[] args) {
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
                //或者 return Integer.compare(o1,o2);
            }
        };

        int compare = comparator.compare(21, 12);// 呼叫該介面中重寫的抽象方法
        System.out.println(compare);
    }
}

在這里插入圖片描述

Lambda運算式的方式：


import java.util.Comparator;

public class LambdaTest01 {
    public static void main(String[] args) {
        Comparator<Integer> comparator = (o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        int compare = comparator.compare(21, 12);// 呼叫該介面中重寫的抽象方法
        System.out.println(compare);


        System.out.println("*****************************");
        // 或者
        Comparator<Integer> comparator1 = (o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return Integer.compare(o1,o2);
        };

        int compare2 = comparator.compare(21, 12);// 呼叫該介面中重寫的抽象方法
        System.out.println(compare2);
    }
}

在這里插入圖片描述

3.6 第六種：有多個引數，有回傳值，一條陳述句

情況6： 介面中抽象方法：有多個引數，有回傳值，只有一條陳述句

Lambda 運算式的語法格式如下：

Comparator<Integer> comparator = (o1,o2)->Integer.compare(o1,o2);
// (引數名1，引數名2)-> return 回傳的值
// 當介面中的抽象方法只有一個回傳值時，其 {} 和 return 都可以省略，注意：要么兩者都省略，要么都不省略，不然編譯無法通過的，

匿名實作介面的方式：


import java.util.Comparator;

public class LambdaTest01 {
    public static void main(String[] args) {
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
                //或者 return Integer.compare(o1,o2);
            }
        };

        int compare = comparator.compare(21, 12);// 呼叫該介面中重寫的抽象方法
        System.out.println(compare);
    }
}

在這里插入圖片描述

Lambda運算式的方式：

import java.util.Comparator;


public class LambdaTest01 {
    public static void main(String[] args) {
        Comparator<Integer> comparator = (o1,o2)->Integer.compare(o1,o2);
        int compare = comparator.compare(21, 12);// 呼叫該介面中重寫的抽象方法
        System.out.println(compare);

    }
}

在這里插入圖片描述

當介面中的抽象方法只有一個回傳值時，其 {} 和 return 都可以省略，注意：要么兩者都省略，要么都不省略，不然編譯無法通過的，

在這里插入圖片描述

3.7 Lambda 運算式六種語法格式總結：

在 Lambda 運算式中：介面中重寫的抽象方法中的引數的資料型別可以省略，Java會自行推斷出來的，
如果 Lambda 運算式中只有一個引數，其一對 {} 花括號可以省略，
如果 Lambda 運算式中只有一條陳述句一個回傳值，則：return 關鍵字和 {} 花括號都可以省略，注意： ：要么兩者都省略，要么都不省略，不然編譯無法通過的
如果介面中的抽象方法有多條陳述句，則需要使用 {} 花括號，括起來，
Lambda 運算式的本質：就是函式式介面的實體，替換匿名實作類的方式
如果一個介面中，只宣告了一個抽象方法，(被 static ,default 修飾的抽象方法不算)，則此介面就稱為 “函式式介面”，

上述Lambda 運算式中的引數型別都是由編譯器推斷得出的，Lambda 運算式中無需指定型別，程式依然可以編譯，這是因為javac根據程式的背景關系，在后臺推斷出了引數的型別，Lambda 運算式的型別依賴于背景關系環境，是由編譯器推斷出來的，這就是所謂的 “型別推斷”

在這里插入圖片描述

3.8 補充：作為引數傳遞 Lambda 運算式

作為引數傳遞 Lambda 運算式：為了將 Lambda 運算式作為引數傳遞，接收Lambda 運算式的引數型別必須是與該 Lambda 運算式兼容的函式式介面的型別，

在這里插入圖片描述

舉例一：

匿名實作介面的方式：

package blogs.blog13;

import java.util.function.Consumer;

public class LambdaTest02 {

    public static void happyTime(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }

    // 匿名實作介面 傳遞介面實體
    public static void main(String[] args) {
        // 呼叫方法
        happyTime(600,new Consumer<Double>() {

            // 重寫 Consumer 介面中的 accept()抽象方法
            @Override
            public void accept(Double aDouble) {
                System.out.println("Hello World");
            }
        });
    }


}

在這里插入圖片描述

Lambda 運算式處理


import java.util.function.Consumer;

public class LambdaTest02 {

    public static void happyTime(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }


    // Lambda 運算式處理
    public static void main(String[] args) {
        // 呼叫方法
        happyTime(600,(Double d)-> System.out.println("Hello World"));
        // (Double d) 是 Consumer 介面中 accept()抽象方法的引數
        // System.out.println("Hello World") 是 Consumer 介面中 accept()抽象方法執行的陳述句，

    }
}

在這里插入圖片描述

舉例二：

匿名實作介面的方式：


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

public class LambdaTest02 {
    /**
     * 根據給定的規則，過濾集合中的字串，此規則由 Predicate 的方法決定
     */
    public static List<String> filterString(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        for(String s : list) {
            if(pre.test(s)) {
                filterList.add(s);
            }
        }

        return filterList;
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("北京","天津","南京","東京","西京");

        List<String> list2 = filterString(list, new Predicate<String>() {
            // 重寫 Predicate 介面中的 test(T t) 抽象方法
            @Override
            public boolean test(String s) {
                return s.contains("京"); // 字串中含有 京 字的回傳 true,否則回傳 false
            }
        });

        System.out.println(list2);
    }
]

在這里插入圖片描述

Lambda 運算式處理


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

public class LambdaTest02 {
    /**
     * 根據給定的規則，過濾集合中的字串，此規則由 Predicate 的方法決定
     */
    public static List<String> filterString(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        for(String s : list) {
            if(pre.test(s)) {
                filterList.add(s);
            }
        }

        return filterList;
    }


    public static void main(String[] args) {
        List<String> list = Arrays.asList("北京","南京","天津","東京","西京");

        List<String> list2 = filterString(list, (String s) -> {
            return s.contains("京");
        });  // 或者 s->s.contaions("京"); // 資料型別可以省略，一條陳述句 return {}也可以省略

        System.out.println(list2);

    }
}

在這里插入圖片描述

4. 函式式介面的概述

只包含一個抽象方法的介面，稱之為 函式式介面
你可以通過 Lambda 運算式來創建該介面的物件，（若 Lambda 運算式拋出一個受檢例外即：非運行時例外），那么該例外需要在目標介面的抽象方法中進行宣告，
我們可以在一個介面上使用 @Functionallnterface 注解，這樣就可以檢查它是否是一個函式式介面，同時 javadoc 也會包含一條宣告，說明這個介面是一個函式式介面，
如果我們在某個介面上宣告了 @FunctionalInterface 注解，那么編譯器就會按照函式式介面的定義來要求該介面，這樣如果有兩個抽象方法，程式編譯就會報錯的，所以，從某種意義上來說，只要你保證你的介面中只有一個抽象方法，你可以不加這個注解，加上就會自動進行檢測的，保證安全，
java.util.functio 包下定義了 java8 豐富的函式式介面，

在這里插入圖片描述

Java從誕生日起就是一直倡導 “一切皆物件” ，在Java里面面向物件(OOP)編程是一切，但是隨著 python,scala 等語言的興起和新技術的挑戰，Java 不得不做出調整以便支持更加廣泛的技術要求，也即 java 不但可以支持 OOP 還可以支持 OOF（面向函式編程） ，

在函式式編程語言當中，函式被當做一等公民對待，在將函式作為一等公民的編程語言中，Lambda 運算式的型別是函式，但是在Java8 中，有所不同，在 Java8 中，Lambda 運算式是物件，而不是函式，它們必須依附于一類特別的物件型別 —— 函式式介面 ，
簡單的說，在 Java8 中，Lambda 運算式就是一個函式式介面的實體，這就是 Lambda 運算式和函式式介面的關系，也就是說，只要一個物件時函式式介面的實體，那么該物件就可以用 Lambda 運算式來表示，所以以前用匿名實作類表示的現在都可以用 Lambda 運算式來寫了，

4.1 自定義函式式介面

@FunctionalInterface
public interface MyInterface01 {
    public abstract void fun();
}

函式式介面中使用泛型


@FunctionalInterface
public interface MyInterface01<T> {
    public abstract T fun(T t);
}

5. Java 內置四大核心函式式介面

5.1 Consumer

函式式介面	引數型別	回傳型別	作用
Consumer消費型介面	T	void	對型別為 T 的物件應用操作，包含抽象方法：void accept(T t)

在這里插入圖片描述

5.2 Supplier

函式式介面	引數型別	回傳型別	作用
Suppolier 供給型介面	無	T	回傳型別為 T 的物件，包含抽象方法為：T get()

在這里插入圖片描述

5.3 Function

函式式介面	引數型別	回傳型別	作用
Function<T,R> 函式型介面	T	R	對型別為 T 的物件應用操作，并回傳結果，結果為 R 型別的物件，包含抽象方法：R apply(T t)

在這里插入圖片描述

5.4 Predicate

函式式介面	引數型別	回傳型別	作用
Predicate 斷定型介面	T	boolean	確定型別為 T的物件是否滿足某約束，并回傳 boolean 值，包含抽象方法：boolean test(T t)

在這里插入圖片描述

5.5 其他的函式式介面

在這里插入圖片描述

6. 方法參考

當要傳遞給 Lambda運算式中（也就是介面中的抽象方法中），內部直接(只是)呼叫的是其他類中已經實作的方法，沒有其他的處理陳述句了，就可以使用方法參考，
方法參考可以看做是 Lambda 運算式深層次的表達，換句話說：方法參考就是 Lambda運算式，可以理解為是 Lambda 的簡寫 ，同樣的既然方法參考就是 Lambda 運算式，那也就是函式式介面的一個實體，因為：Lambda 運算式的本質：就是作為介面的實體，簡單的說就是對匿名實作介面的替換，通過方法的名字來指向一個方法，可以認為是 Lambda 運算式的一個語法糖 ，

想要使用方法參考：需要滿足一些條件： 實作的介面的抽象方法的引數串列和回傳值型別，必須與方法參考的方法的引數串列和回傳值型別保持一致，換句話說：就是我們介面中重寫的抽象方法內部呼叫的其他類已經實作的方法的，這兩者之間的方法的（引數串列）和 return 回傳型別要一致，不然不可以使用方法參考，

如下圖

在這里插入圖片描述

使用方法參考的語法格式如下： 使用運算子 :: 將類(或物件) 與方法名分隔開來，

import java.util.function.Consumer;

public class MethodRefTest {
    public static void main(String[] args) {
        Consumer<String> consumer = System.out::println;
        
        consumer.accept("Hello World");

    }
}

常用的方法參考有如下三種情況：

物件::實體方法名 ：物件名參考實體方法
類::靜態方法名 ：類名參考靜態方法
類:: 實體方法名 類名參考實體方法名，這里這里沒有寫錯，
注意物件不可參考靜態方法

這里會將上述三種情況：分別使用 Lambda 運算式與方法參考，匿名實作介面處理同一個功能，通過比較這三種方式，來理解方法參考

6.1 情況1：物件::實體方法名

補充： Consumer 和 PrintStream 對應方法參考的原始碼：
在這里插入圖片描述

舉例：


import java.util.function.Consumer;

public class MethodRefTest {
    /**
     * 情況一: 物件 :: 實體方法
     * Consumer 中的 void accept(T t)
     * PrintStream 中的 void println(T t)
     */
    public static void main(String[] args) {
        // 匿名實作介面的方式：
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("匿名實作介面的方式: " + s);
            }
        };
        
        consumer1.accept("Hello World");

        // Lambda 運算式
        Consumer<String> consumer2 = s-> System.out.println("Lambda 運算式: " + s);
        consumer2.accept("Hello World");

        // 方法參考
        Consumer<String> consumer = System.out::println;
        consumer.accept("Hello World");

    }
}

在這里插入圖片描述

舉例：

補充：Supplier 介面中的抽象方法與 Employee 中的方法的原始碼比較

在這里插入圖片描述


import day33.java.Employee;

import java.io.PrintStream;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class MethodRefTest {
    /**
     * Supplier 中的 T get()
     * Employee 中的String getName()  兩者的方法結構是一樣的，
     */
    public static void main(String[] args) {
        // 匿名實作介面的方式：
        Employee emp = new Employee(1001,"Tom",23,5600);
        Supplier<String> supplier1 = new Supplier<String>() {
            @Override
            public String get() {
                return emp.getName();
            }
        };
        String regStr1 = supplier1.get();  // 呼叫其 Supplier 重寫的get()抽象方法
        System.out.println(regStr1);
        
        // Lambda 運算式
        Supplier<String> supplier2 = ()->emp.getName();
        String regStr2 = supplier2.get();  // 呼叫其 Supplier 重寫的get()抽象方法
        System.out.println(regStr2);


        // 方法參考
        Supplier<String> supplier3 = emp::getName;
        String regStr3 = supplier3.get();  // 呼叫其 Supplier 重寫的get()抽象方法
        System.out.println(regStr3);
    }
}

在這里插入圖片描述

6.2 情況2：類::靜態方法

舉例：

補充： Comparator中的compare 方法與 Integer 中的compare 方法

在這里插入圖片描述

package blogs.blog13;

import java.util.Comparator;

public class MethodRefTest02 {
    /**
     * 情況二: 類 :: 靜態方法
     * Comparator 中的 int compare(T t1,T t2)
     * Integer 中的 int compare(T t1,T t2) 兩者之間的結構一致
     */
    public static void main(String[] args) {
        // 匿名實作介面方式
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare = comparator.compare(12, 21);  // 呼叫其Comparator介面中重寫的compare()抽象方法
        System.out.println(compare);


        // Lambda 運算式
        Comparator<Integer> comparator2 = (o1,o2)->Integer.compare(o1,o2);
        int compare2 = comparator2.compare(12, 21);  // 呼叫其Comparator介面中重寫的compare()抽象方法
        System.out.println(compare2);
        
        // 方法參考
        Comparator<Integer> comparator3 = Integer::compareTo;
        int compare3 = comparator3.compare(12, 21);  // 呼叫其Comparator介面中重寫的compare()抽象方法
        System.out.println(compare3);
    }
}

在這里插入圖片描述

舉例：

補充：

在這里插入圖片描述


import java.util.function.Function;

public class MethodRefTest02 {
    /**
     * Function  中的 apply(T t)
     * Math 中的 Long round(Double d)  // 四舍五入
     *   兩個方法的結構一致，
     */
    public static void main(String[] args) {
        // 匿名實作介面的方式
        Function<Double,Long> function = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d); // 四舍五入
            }
        };

        Long apply = function.apply(12.3);  // 呼叫Function 介面中的重寫的apply()方法
        System.out.println(apply);

        // Lambda 運算式
        Function<Double,Long> function2 = d->Math.round(d);
        Long apply2 = function2.apply(12.3);  // 呼叫Function 介面中的重寫的apply()方法
        System.out.println(apply2);
        
        // 方法參考
        Function<Double,Long> function3 = Math::round;
        Long apply3 = function3.apply(12.3);  // 呼叫Function 介面中的重寫的apply()方法
        System.out.println(apply3);


    }
}

在這里插入圖片描述

6.3 情況3：類::實體方法

舉例：

補充： BiPredicate 中的 boolean test(T t1, T t2) 和 String 中的 boolean t1.equals(t2) 這兩者之間的方法的結構也是一致的，這個比較特殊，

在這里插入圖片描述


import java.util.function.BiPredicate;

public class MethodRefTest03 {
    /**
     * BiPredicate 中的 boolean test(T t1, T t2) ;
     * String 中的 boolean t1.equals(t2)
     */
    public static void main(String[] args) {
        // 匿名實作介面的方式：
        BiPredicate<String,String> biPredicate = new BiPredicate<String, String>() {
            @Override
            public boolean test(String s, String s2) {
                return s.equals(s);
            }
        };
        boolean test = biPredicate.test("ab", "ab"); // 呼叫BiPredicate介面中的 test()抽象方法
        System.out.println(test);


        // Lambda 運算式
        BiPredicate<String, String> biPredicate2 = (s1, s2) -> s1.equals(s2);
        boolean test2 = biPredicate2.test("ab", "ab"); // 呼叫BiPredicate介面中的 test()抽象方法
        System.out.println(test2);

        
        // 方法參考
        BiPredicate<String,String> biPredicate3 = String::equals;
        boolean test3 = biPredicate3.test("ab", "ab");
        System.out.println(test3);

    }
}

在這里插入圖片描述

舉例：

補充： Function 中的 R apply(T t) 和 Employee 中的 String getName(); 兩者方法的結構是一致的

在這里插入圖片描述


import java.util.function.Function;

public class MethodRefTest03 {
    /**
     * Function 中的 R apply(T t)
     * Employee 中的 String getName(); 兩者方法的結構是一致的
     */
    public static void main(String[] args) {
        Employee employee = new Employee(1001,"Jerry",23,60000);

        // 匿名實作介面
        Function<Employee,String> function = new Function<Employee, String>() {
            @Override
            public String apply(Employee employee) {
                return employee.getName();
            }
        };
        String apply = function.apply(employee);  // 呼叫 Function 介面中的 重寫的apply()抽象方法
        System.out.println(apply);

        // Lambda 運算式
        Function<Employee,String> function2 = e->e.getName();  //一個引數，一條陳述句，一個回傳值 () {} 可以省略
        String apply2 = function2.apply(employee);  // 呼叫 Function 介面中的 重寫的apply()抽象方法
        System.out.println(apply2);

        // 方法參考
        Function<Employee,String> function3 = Employee::getName; // Function 介面中的 apply()抽象方法
        // 實際上在該重寫的抽象方法中呼叫的是 Employee 類中的 getName()方法，
        String apply3 = function3.apply(employee);  // 呼叫 Function 介面中的 重寫的apply()抽象方法
        System.out.println(apply3);
    }
}

在這里插入圖片描述

7. 構造器參考

構造器參考： 與函式式介面相結合，自動與函式式介面方法兼容，

可以把構造器參考賦值給定義的方法，要求：構造器引數串列要與介面中抽象方法的引數串列一致，且方法的回傳值即為構造器對應類的物件， 注意： 該介面中重寫的抽象方法，僅僅只是呼叫了其他類中的構造器（new 物件）就沒有其它的邏輯陳述句了，只有一條陳述句才可以使用 構造器參考，

格式如下：

ClassName::new; 類名::new

如下是通過比較：匿名實作類，Lambda 運算式，以及構造器參考，三者之間的實作同以功能的比較，從而理解構造器參考

舉例1：

補充： Supplier中的 T get() 與 Employee 中的無參構造器的結構

在這里插入圖片描述

package blogs.blog13;


import day33.java.Employee;

import java.util.function.Supplier;

public class ConstructorRefTest {
    /**
     *
     * Supplier中的 T get()
     */
    public static void main(String[] args) {
        // 匿名實作介面
        Supplier<Employee> supplier = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        Employee employee = supplier.get();  // 呼叫 Supplier 介面中重寫 get()的抽象方法
        System.out.println(employee);

        // Lambda 運算式
        Supplier<Employee> supplier2 = ()->new Employee();
        Employee employee2 = supplier2.get();  // 呼叫 Supplier 介面中重寫 get()的抽象方法
        System.out.println(employee2);

        // 構造器參考
        Supplier<Employee> supplier3 = Employee::new;
        Employee employee3 = supplier3.get();  // 呼叫 Supplier 介面中重寫 get()的抽象方法
        System.out.println(employee3);
    }
}

在這里插入圖片描述

舉例：

補充： Function中的R apply(T t) 與 Employee (int id) 的結構
在這里插入圖片描述


import day33.java.Employee;

import java.util.function.Function;

public class ConstructorRefTest {
    /**
     *
     * Function中的R apply(T t)
     */
    public static void main(String[] args) {
        // 匿名實作介面的方式
        Function<Integer,Employee> function = new Function<Integer, Employee>() {
            @Override
            public Employee apply(Integer integer) {
                return new Employee(integer);
            }
        };
        Employee apply = function.apply(100);  // 呼叫function介面中重寫的apply()抽象方法
        System.out.println(apply);

        // Lambda  運算式
        Function<Integer,Employee> function2 = id->new Employee(id);
        Employee apply2 = function2.apply(100);  // 呼叫function介面中重寫的apply()抽象方法
        System.out.println(apply2);

        // 構造器參考
        Function<Integer,Employee> function3 = Employee::new;
        Employee apply3 = function3.apply(100);  // 呼叫function介面中重寫的apply()抽象方法
        System.out.println(apply3);

    }
}

在這里插入圖片描述

舉例：

補充：

在這里插入圖片描述


import day33.java.Employee;

import java.util.function.BiFunction;


public class ConstructorRefTest {
    /**
     *BiFunction中的R apply(T t,U u)
     */
    public static void main(String[] args) {
        // 匿名實作介面的方式
        BiFunction<Integer,String,Employee> biFunction = new BiFunction<Integer, String, Employee>() {
            @Override
            public Employee apply(Integer integer, String s) {
                return new Employee(integer,s);
            }
        };
        Employee employee = biFunction.apply(100, "Tom"); // 呼叫 BiFunction 介面中的 apply()抽象方法
        System.out.println(employee);

        // Lambda 運算式
        BiFunction<Integer,String,Employee> biFunction2 = (id,name)->new Employee(id,name);
        Employee employee2 = biFunction2.apply(100, "Tom"); // 呼叫 BiFunction 介面中的 apply()抽象方法
        System.out.println(employee2);

        // 構造器參考
        BiFunction<Integer,String,Employee> biFunction3 = Employee::new;
        Employee employee3 = biFunction3.apply(100, "Tom"); // 呼叫 BiFunction 介面中的 apply()抽象方法
        System.out.println(employee3);

    }
}

在這里插入圖片描述

8. 陣列參考

資料參考 與構造器參考基本上是一樣的，稍微不同的就是在 型別[] 多了個方括號表示陣列而已

格式如下：

type[] :: new;// 資料型別[]::new

在這里插入圖片描述

舉例：

補充： Function 介面原始碼

在這里插入圖片描述

package blogs.blog13;

import java.util.Arrays;
import java.util.function.Function;

public class ConstructorRefTest02 {
    /**
     * Function中的R apply(T t)
     */
    public static void main(String[] args) {
        // 匿名實作介面 <> 注意泛型不能使用基本資料型別
        Function<Integer,String[]> function = new Function<Integer, String[]>() {
            @Override
            public String[] apply(Integer integer) {
                return new String[integer];
            }
        };

        String[] apply = function.apply(5);  // 呼叫 Function 介面中的 重寫的apply()抽象方法
        System.out.println(Arrays.toString(apply));

        // Lambda 運算式
        Function<Integer,String[]> function2 = (leng)->new String[leng];
        String[] apply2 = function2.apply(5);  // 呼叫 Function 介面中的 重寫的apply()抽象方法
        System.out.println(Arrays.toString(apply2));

        
        // 陣列參考
        Function<Integer,String[]> function3 = String[]::new;
        String[] apply3 = function3.apply(5);  // 呼叫 Function 介面中的 重寫的apply()抽象方法
        System.out.println(Arrays.toString(apply3));

    }
}

在這里插入圖片描述

9. Lambda 運算式的優缺點：

Lambda運算式的優點很明顯，在代碼層次上來說，使代碼變得非常的簡潔，缺點也很明顯，代碼不易讀，可讀性比較低，

優點：

代碼簡潔，開發迅速，

方便函式式編程，

非常容易進行并行計算，

Java 引入 Lambda，改善了集合操作，如集合的排序，遍歷，優先級佇列自定義大小堆等，

缺點：

代碼可讀性變差，

在非并行計算中，很多計算未必有傳統的 for 性能要高，

不容易進行除錯，

10. 總結:

重點：Lambda 運算式的本質：就是作為介面的實體，簡單的說就是對匿名實作介面的替換，
Lambda 運算式的常見的六種語法格式
如果一個介面中只有一個抽象方法，(static ,default) 稱為函式式介面
如果我們在某個介面上宣告了 @FunctionalInterface 注解，那么編譯器就會按照函式式介面的定義來要求該介面，這樣如果有兩個抽象方法，程式編譯就會報錯的，所以，從某種意義上來說，只要你保證你的介面中只有一個抽象方法，你可以不加這個注解，加上就會自動進行檢測的，保證安全，
方法參考，本質上就是 Lambda 運算式，而 Lambda 運算式作為函式介面(匿名實作介面重寫其抽象方法)的實體，所以方法參考，也是函式式介面的實體，
方法參考的滿足的要求：實作的介面的抽象方法的引數串列和回傳值型別，必須與方法參考的方法的引數串列和回傳值型別保持一致，換句話說：就是我們介面中重寫的抽象方法內部呼叫的其他類已經實作的方法的，這兩者之間的方法的（引數串列）和 return 回傳型別要一致，不然不可以使用方法參考，
方法參考的常見三種情況：物件::實體方法，類::靜態方法，類::實體方法
構造器參考的要求：構造器引數串列要與介面中抽象方法的引數串列一致，且方法的回傳值即為構造器對應類的物件， 注意： 該介面中重寫的抽象方法，僅僅只是呼叫了其他類中的構造器（new 物件）就沒有其它的邏輯陳述句了，只有一條陳述句才可以使用 構造器參考，
資料參考 與構造器參考基本上是一樣的，稍微不同的就是在 型別[] 多了個方括號表示陣列而已
Lambda 運算式的優缺點，

11. 最后：

限于自身水平，其中存在的錯誤，希望大家給予指教，韓信點兵——多多益善，謝謝大家，江湖再見，后會有期！！！

在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/545910.html

標籤：其他

上一篇：java對接SCOM微軟監控系統告警

下一篇：【Java】先return還是先finally