Lambda 表達式(Lambda Expression),相信大家對 Lambda 肯定是很熟悉的,畢竟我們數學上經常用到它,即 λ 。不過,感覺數學中的 Lambda 和編程語言中的 Lambda 表達式沒啥關係,要說有關係就是都有 Lambda 這個詞,噢!當然還有一個關係就是 Lambda ... ...
前言
Lambda 表達式(Lambda Expression),相信大家對 Lambda 肯定是很熟悉的,畢竟我們數學上經常用到它,即 λ 。不過,感覺數學中的 Lambda 和編程語言中的 Lambda 表達式沒啥關係,要說有關係就是都有 Lambda 這個詞,噢!當然還有一個關係就是 Lambda 演算。
λ 演算(英語:lambda calculus,λ-calculus)是一套從數學邏輯中發展,以變數綁定和替換的規則,來研究函數如何抽象化定義、函數如何被應用以及遞歸的形式系統。它由數學家阿隆佐·邱奇在20世紀30年代首次發表。lambda演算作為一種廣泛用途的計算模型,可以清晰地定義什麼是一個可計算函數,而任何可計算函數都能以這種形式表達和求值,它能模擬單一磁帶圖靈機的計算過程。
回到編程語言這方面,其實不只是 Java 引入了這個 Lambda 表達式,其他編程語言也有,比如 C++、Javascript、Python 等等。當然,本篇文章回顧的是 Java 中的 Lambda 表達式。
作為一個初學者,下麵對於 Lambda 的理解肯定不夠嚴謹,甚至可能包含錯誤,望觀眾老爺們能在評論區指出!
為什麼要學這個 Lambda 表達式?
- Java 8 的新特性,簡化代碼的編寫。
- 工作中會用到,防止看不懂別人寫的代碼。
- 大家都學我也學。
什麼是 Lambda 表達式?
Lambda 表達式是一個匿名函數,換句話說,你有匿名函數,那麼它這個函數就是所謂的 Lambda 表達式。
所謂匿名函數,顧名思義,就是沒有函數名的函數。
那麼肯定有小伙伴會說,沒有函數名,那我怎麼調用這個函數啊?
是的,這個問題問得很好,先保持這個疑問!在回答這個問題之前,我先來說說另一個概念——「函數式編程」。
什麼是函數式編程?
函數式編程是一種編程範式,除此之外,還有聲明式編程、命令式編程,也都是編程範式。
好吧,這裡又扯出一個新的專業名詞——「編程範式(Programming Paradigm)」。範式?相信正在閱讀的你,在學習資料庫知識的時候,肯定學過第一範式、第二範式、第三範式,那現在又有一個編程範式,這是什麼鬼?
百度百科是這樣說的:
編程範型、編程範式或程式設計法(英語:Programming paradigm),(範即模範、典範之意,範式即模式、方法),是一類典型的編程風格,是指從事軟體工程的一類典型的風格(可以對照方法學)。如:函數式編程、程式編程、面向對象編程、指令式編程等等為不同的編程範型。
是不是太官方了,沒關係,簡單理解,我認為知道函數式編程是一種寫代碼時的風格就OK了。
我們需要註意的是,函數式編程中的「函數」二字,是數學上的函數,並不是我們現在習慣理解的函數,也就是說,這是純純數學概念上的函數,即自變數的映射,比如 $y = f(x)$,自變數 $x$,通過函數 $f$ 映射成 $y$ 。
函數式編程和 Lambda 表達式有什麼關係?
可以說,函數式編程允許使用一種表達式來表示一個函數,這種表達式就是 Lambda 表達式。
在 Java 中,函數式編程是通過一個介面規範來實現的,介面具有這種特點:
- 該介面有且只有一個抽象方法
- 該介面使用
@FunctionalInterface
註解進行標識
具有這個特點的介面稱為「函數式介面」。
現在,回到最開始說的,「沒有函數名,那我怎麼調用這個函數啊?」,這就是函數式介面的用途了,介面中只有一個抽象方法,不用指定方法名稱,就能夠用 Lambda 表達式來調用這個函數(方法)了,不需要知道函數名就能夠實現調用。好比想在某個房間(介面)找個人(方法)來做事,我這個房間只有一個人,那麼除了這個人,沒有其他人可以來做事了,就不需要指定那誰誰誰過來幫忙,而是直接喊:就決定是你了!(這個比喻可能也不是很恰當,當大概意思是這樣哈哈哈)
函數式介面
Comparator
我們可以看看 Comparator 介面,它有 @FunctionalInterface
註解,那麼可以肯定它是一個函數式介面。
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator<T> reversed() {
return Collections.reverseOrder(this);
}
default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}
...
}
有小伙伴應該要說了,這個介面這麼多方法,為什麼還能是函數式介面?
註意了啊,我們可以看到一個好像是抽象的 equals
方法,但是,因為 equals
是 Object 中的方法,這種對Object 類的方法的重新聲明是會讓方法變成一個具體的方法。所以,不要誤會了,這裡的抽象方法就只有 compare
方法。
那可能有小伙伴要說了,介面中還能有具體的方法?
是的,沒錯,在 Java 8 中,介面中可以寫具體的方法了。比如上面的 reversed
和 thenComparing
方法,都是具體的方法。
常見的函數式介面
- java.lang.Runnable
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
- java.util.concurrent.Callable
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
- java.lang.reflect.InvocationHandler
@FunctionalInterface
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
如何使用 Lambda 表達式?
在 Java 8 之前,我們使用 Collections 的需要比較器的 sort 方法,是這樣的。
等等,忘了有比較器參數的 sort 方法了?沒關係,代碼給你貼上:
public static <T> void sort(List<T> list, Comparator<? super T> c) {
list.sort(c);
}
最開始的寫法是這樣的,由於 Comparator 是一個介面,不能直接實例化,所以需要一個類來實現這個介面作為真正的比較器類,然後將這個 Comparator 實例對象作為 sort 方法第二個參數傳入,實現排序,如下:
public class KeyComparator implements Comparator<Integer> {
@Override
public int compare(Integer v1, Integer v2) {
return v1 - v2;
}
}
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, new KeyComparator());
System.out.println(keys); // [2, 3, 5, 9, 10]
後來,這種寫法比較麻煩,於是用匿名內部類改寫這種寫法,我們不需要自己去編寫一個類來實現這個介面了,直接用匿名內部類。就是這種寫法:
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, new Comparator<Integer>() {
@Override
public int compare(Integer v1, Integer v2) {
return v1 - v2;
}
});
System.out.println(keys); // [2, 3, 5, 9, 10]
現在,匿名內部類比起 Lambda 表達式,也是麻煩,我們用 Lambda 進行改寫:
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, (Integer v1, Integer v2) -> {return v1 - v2;});
System.out.println(keys); // [2, 3, 5, 9, 10]
是吧,(Integer v1, Integer v2) -> {return v1 - v2;}
的寫法,沒有函數名,也能進行調用。
實際上,這樣還不是最簡的,最簡的是這樣:(v1, v2) -> v1 - v2
是不是很好奇啥時候能這樣寫?現在就告訴你!
基本語法
(參數類型 參數名) -> { 方法體 }
基本上,這樣寫,是不會有問題的。下麵說說何時能寫得更加簡單。
為了便於閱讀,下麵的「方法」指的是函數式介面中的抽象方法
- 方法沒有參數,那麼可以直接寫小括弧,然後箭頭,再寫中括弧,最後寫方法體,即
() -> { 方法體 }
- 方法有多個參數,那麼多個參數就用逗號分開,同時參數類型是可以省略的,即
(v1, v2, ...) -> {方法體}
- 方法只有一個參數,那麼小括弧可以去掉,直接寫參數名,然後箭頭,再中括弧和方法體,即
v -> {方法體}
- 方法體只有一條語句,無論是否有返回值,都可以省略大括弧、return 關鍵字及語句分號。
情況一:方法無參數、無返回值
常見的就是 Runnable
介面了。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
- 未使用 Lambda(使用匿名內部類):
new Thread(new Runnable() {
@Override
void run() {
System.out.println("線程開始跑了");
}
}).start();
- 使用 Lambda:
// 寫法一
new Thread(() -> {
System.out.println("線程開始跑了")
}).start();
// 寫法二,一條語句,那麼省略大括弧、return 關鍵字及語句分號
new Thread(() -> System.out.println("線程開始跑了")).start();
情況二:方法無參數,有返回值
例子:Callable 介面
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
- 未使用 Lambda(使用匿名內部類):
FutureTask<String> stringFutureTask = new FutureTask<>(new Callable<String>() {
@Override
public String call() throws Exception {
return "這裡是返回值";
}
});
stringFutureTask.run();
System.out.println(stringFutureTask.get());
- 使用 Lambda:
// 一條語句,省略大括弧、return 關鍵字及語句分號
FutureTask<String> stringFutureTask = new FutureTask<>(() -> "這裡是返回值");
stringFutureTask.run();
System.out.println(stringFutureTask.get());
情況三:方法一個參數、有返回值
我隨便找了 JDK 中的一個介面,如下:
@FunctionalInterface
interface Recognizer {
boolean recognize(int c);
}
- 未使用 Lambda(使用匿名內部類):
private final Recognizer A = new Recognizer() {
@Override
public boolean recognize(int c) {
return c == 'a' || c == 'A';
}
}
- 使用 Lambda:
private final Recognizer A = (c) -> c == 'a' || c == 'A';
// 一個參數,可省略小括弧
private final Recognizer A = c -> c == 'a' || c == 'A';
情況四:方法多個參數、有返回值
直接舉 Comparator 這個例子。
- 未使用 Lambda(使用匿名內部類):
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
keys.sort(new Comparator()<Integer> {
@Override
public int compare(Integer v1, Integer v2) {
return v1 - v2;
}
});
- 使用 Lambda:
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
// 多個參數以逗號分開,可省略類型,一條語句,省略大括弧、return 關鍵字及語句分號
keys.sort((v1, v2) -> v1 - v2);
System.out.println(keys);
總結
到這裡,相信大家對於 Lambda 表達式有了一個基本的認識。總的來說:
- 必須是函數式介面才能使用 Lambda 表達式
語法:(參數類型 參數名稱) ‐> { 方法體 }
- 若方法的參數列表:
- 沒有參數,則可直接用
()
; - 有一個參數,可以省略
()
,直接寫參數; - 有多個參數,則
()
不可省略 ()
內的參數類型可以省略
- 沒有參數,則可直接用
- 若方法體:
- 只有一條語句,無論是否有返回值,都可以省略大括弧、return 關鍵字及語句分號。
- 處理邏輯過於臃腫複雜,還是使用具體子類改寫較好,保證可讀性。
最後的最後
由本人水平所限,難免有錯誤以及不足之處, 屏幕前的靚仔靚女們
如有發現,懇請指出!
最後,謝謝你看到這裡,謝謝你認真對待我的努力,希望這篇博客對你有所幫助!
你輕輕地點了個贊,那將在我的心裡世界增添一顆明亮而耀眼的星!