曾經讀過的依然令我感動的句子,生活總是不如意,但往往是在無數痛苦中,但往往是在無數痛苦中,在重重矛盾
和艱難中才能成熟起來,堅強起來,愛情啊,它使荒蕪變成繁榮,平庸變得偉大,使死去的復活,活著的閃閃發光,
即使愛情是不盡的煎熬折磨,像冰霜般嚴厲,烈火般烤灼,但愛情對心和身體健男女是那樣的自然,同時又永遠讓我們感到新奇神祕和不可思議....... 。生活中真正的勇士向來默默無聞,喧譁不止的永遠是自視高貴的一群,無論精神是多麼獨立,感情卻總是在尋找以一種依附,尋找一種歸宿,親人之間的感情是多麼重要,假如沒有這種感情,我們活在這個世界是多麼悲哀啊,只有勞動才能使人在
生活中強大,不論什麼人,最終還是要崇尚哪些用雙手創造生活的財富者,人們寧願關心一個蹩腳的電影演。
—————— 《平凡的世界》路遙
@
我們先看看什麼是函數。函數是一種最基本的任務,一個大型程式就是一個頂層函數呼叫若干底層函數,這些被呼叫的函數又可以呼叫其他函數,即大任務被一層層拆解並執行。所以函數就是程式導向的程式設計的基本單元。
Java不支援單獨定義函數,但可以把靜態方法視為獨立的函數,把實體方法視為自帶this
引數的函數。
而函數語言程式設計(請注意多了一個「式」字)——Functional Programming,雖然也可以歸結到程式導向的程式設計,但其思想更接近數學計算。
我們首先要搞明白計算機(Computer)和計算(Compute)的概念。
在計算機的層次上,CPU執行的是加減乘除的指令程式碼,以及各種條件判斷和跳轉指令,所以,組合語言是最貼近計算機的語言。
而計算則指數學意義上的計算,越是抽象的計算,離計算機硬體越遠。
對應到程式語言,就是越低階的語言,越貼近計算機,抽象程度低,執行效率高,比如C語言;越高階的語言,越貼近計算,抽象程度高,執行效率低,比如Lisp語言。
函數語言程式設計就是一種抽象程度很高的程式設計正規化,純粹的函數語言程式設計語言編寫的函數沒有變數,因此,任意一個函數,只要輸入是確定的,輸出就是確定的,這種純函數我們稱之為沒有副作用。而允許使用變數的程式設計語言,由於函數內部的變數狀態不確定,同樣的輸入,可能得到不同的輸出,因此,這種函數是有副作用的。
函數語言程式設計的一個特點就是,允許把函數本身作為引數傳入另一個函數,還允許返回一個函數!
函數語言程式設計最早是數學家阿隆佐·邱奇研究的一套函數變換邏輯,又稱Lambda Calculus(λ-Calculus),所以也經常把函數語言程式設計稱為Lambda計算。
Java平臺從Java 8開始,支援函數語言程式設計。
相信大家一定在相關的框架的原始碼中看到不少 使用了 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 表示式解決的程式碼量更少一些。
Lambda 表示式:在 Java 8 語言中引入的一種新的語法元素和操作符。這個操作符為 ->
一槓 + 一個左箭頭,該操作符被稱為 Lambda 操作符 或 箭頭操作符 。它將 Lamdba 分為兩個部分。
箭頭左側 : 指定了 Lambda 表示式需要的參數列 。其實就是對應介面中的重寫抽象方法中的參數列。
箭頭右側 :指定了 Lambda 體,即為 Lambda 表示式要執行的功能。其實就是對應介面中共重寫抽象方法中的所要執行的語句/處理的邏輯。
一般的具體格式如下:
Runnable runnable = ()->System.out.println("你好世界");
()-> { lambda 體所要執行的語句}
我們知道 Lambda 表示式的本質就是:介面的範例化。匿名實現介面的替換 。既然要實現 介面 ,自然也就要重寫其介面的抽象方法了。不同的介面中的抽象方法其結構也是不一樣的。既然抽象方法都不一樣了,那對應的介面中的 Lambda 表示式也有所不同了。
具體可以分為如下六種對應不同介面中的抽象方法中的不同的 Lambda 表示式的語法格式
這裡我們會通過實現同樣的功能,使用 匿名實現介面 與 Lambda 表示式 進行處理,兩者之間進行一個對比,這樣更容易理解 Lambda 表示式。
情況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();
}
}
情況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: 介面中的抽象方法有引數,但是該引數的資料型別可以省略不寫(你也可以寫上),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("你好"); // 呼叫介面中重寫的抽象方法
}
}
情況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("你好"); // 呼叫介面中重寫的抽象方法
}
}
情況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);
}
}
情況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 都可以省略,注意:要麼兩者都省略,要麼都不省略,不然編譯無法通過的。
{}
花括號可以省略。{}
花括號。括起來。上述Lambda 表示式中的引數型別都是由編譯器推斷得出的。Lambda 表示式中無需指定型別,程式依然可以編譯,這是因為javac根據程式的上下文,在後臺推斷出了引數的型別。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);
}
}
@Functionallnterface
註解,這樣就可以檢查它是否是一個函數式介面。同時 javadoc 也會包含一條宣告,說明這個介面是一個函數式介面。@FunctionalInterface
註解,那麼編譯器就會按照函數式介面的定義來要求該介面,這樣如果有兩個抽象方法,程式編譯就會報錯的。所以,從某種意義上來說,只要你保證你的介面中只有一個抽象方法,你可以不加這個註解。加上就會自動進行檢測的,保證安全。Java從誕生日起就是一直倡導 「一切皆物件」 ,在Java裡面物件導向(OOP)程式設計是一切。但是隨著 python,scala 等語言的興起和新技術的挑戰,Java 不得不做出調整以便支援更加廣泛的技術要求,也即 java 不但可以支援 OOP 還可以支援 OOF(面向函數程式設計) 。
@FunctionalInterface
public interface MyInterface01 {
public abstract void fun();
}
函數式介面中使用泛型
@FunctionalInterface
public interface MyInterface01<T> {
public abstract T fun(T t);
}
函數式介面 | 引數型別 | 返回型別 | 作用 |
---|---|---|---|
Consumer |
T | void | 對型別為 T 的物件應用操作,包含抽象方法:void accept(T t) |
函數式介面 | 引數型別 | 返回型別 | 作用 |
---|---|---|---|
Suppolier |
無 | T | 返回型別為 T 的物件,包含抽象方法為:T get() |
函數式介面 | 引數型別 | 返回型別 | 作用 |
---|---|---|---|
Function<T,R> 函數型介面 | T | R | 對型別為 T 的物件應用操作,並返回結果。結果為 R 型別的物件,包含抽象方法:R apply(T t) |
函數式介面 | 引數型別 | 返回型別 | 作用 |
---|---|---|---|
Predicate |
T | boolean | 確定型別為 T的物件是否滿足某約束,並返回 boolean 值。包含抽象方法:boolean test(T t) |
想要使用方法參照:需要滿足一些條件: 實現的介面的抽象方法的參數列和返回值型別,必須與方法參照的方法的參數列和返回值型別保持一致。換句話說:就是我們介面中重寫的抽象方法內部呼叫的其他類已經實現的方法的,這兩者之間的方法的(參數列)和 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 表示式 與 方法參照,匿名實現介面 處理同一個功能,通過比較這三種方式,來理解方法參照
補充: 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);
}
}
舉例:
補充: 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);
}
}
舉例:
補充: 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);
}
}
構造器參照: 與函數式介面相結合,自動與函數式介面方法相容。
可以把構造器參照賦值給定義的方法,要求:構造器參數列要與介面中抽象方法的參數列一致,且方法的返回值即為構造器對應類的物件。 注意: 該介面中重寫的抽象方法,僅僅只是呼叫了其他類中的 構造器 (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);
}
}
資料參照 與構造器參照基本上是一樣的,稍微不同的就是在 型別[]
多了個方括號表示陣列而已
格式如下:
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));
}
}
Lambda表示式的優點很明顯,在程式碼層次上來說,使程式碼變得非常的簡潔,缺點也很明顯,程式碼不易讀,可讀性比較低。
優點:
- 程式碼簡潔,開發迅速。
- 方便函數語言程式設計。
- 非常容易進行平行計算。
- Java 引入 Lambda,改善了集合操作,如集合的排序,遍歷,優先順序佇列自定義大小堆等。
缺點:
- 程式碼可讀性變差。
- 在非平行計算中,很多計算未必有傳統的 for 效能要高。
- 不容易進行偵錯。
@FunctionalInterface
註解,那麼編譯器就會按照函數式介面的定義來要求該介面,這樣如果有兩個抽象方法,程式編譯就會報錯的。所以,從某種意義上來說,只要你保證你的介面中只有一個抽象方法,你可以不加這個註解。加上就會自動進行檢測的,保證安全。型別[]
多了個方括號表示陣列而已限於自身水平,其中存在的錯誤,希望大家給予指教,韓信點兵——多多益善,謝謝大家,江湖再見,後會有期 !!!