函數語言程式設計：Lambda 表示式
每博一文案
曾經讀過的依然令我感動的句子，生活總是不如意，但往往是在無數痛苦中，但往往是在無數痛苦中，在重重矛盾
和艱難中才能成熟起來，堅強起來，愛情啊，它使荒蕪變成繁榮，平庸變得偉大，使死去的復活，活著的閃閃發光，
即使愛情是不盡的煎熬折磨，像冰霜般嚴厲，烈火般烤灼，但愛情對心和身體健男女是那樣的自然，同時又永遠讓我們感到新奇神秘和不可思議....... 。生活中真正的勇士向來默默無聞，喧譁不止的永遠是自視高貴的一群，無論精神是多麼獨立，感情卻總是在尋找以一種依附，尋找一種歸宿，親人之間的感情是多麼重要，假如沒有這種感情，我們活在這個世界是多麼悲哀啊，只有勞動才能使人在
生活中強大，不論什麼人，最終還是要崇尚哪些用雙手創造生活的財富者，人們寧願關心一個蹩腳的電影演。
—————— 《平凡的世界》路遙
@
目錄
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. 最後：
限於自身水平，其中存在的錯誤，希望大家給予指教，韓信點兵——多多益善，謝謝大家，江湖再見，後會有期 ！！！
