《回爐重造》——Lambda 表示式

god23bin發表於2023-03-10

前言

Lambda 表示式（Lambda Expression），相信大家對 Lambda 肯定是很熟悉的，畢竟我們數學上經常用到它，即 λ 。不過，感覺數學中的 Lambda 和程式語言中的 Lambda 表示式沒啥關係，要說有關係就是都有 Lambda 這個詞，噢！當然還有一個關係就是 Lambda 演算。

λ 演算（英語：lambda calculus，λ-calculus）是一套從數學邏輯中發展，以變數繫結和替換的規則，來研究函式如何抽象化定義、函式如何被應用以及遞迴的形式系統。它由數學家阿隆佐·邱奇在20世紀30年代首次發表。lambda演算作為一種廣泛用途的計算模型，可以清晰地定義什麼是一個可計算函式，而任何可計算函式都能以這種形式表達和求值，它能模擬單一磁帶圖靈機的計算過程。

回到程式語言這方面，其實不只是 Java 引入了這個 Lambda 表示式，其他程式語言也有，比如 C++、Javascript、Python 等等。當然，本篇文章回顧的是 Java 中的 Lambda 表示式。

作為一個初學者，下面對於 Lambda 的理解肯定不夠嚴謹，甚至可能包含錯誤，望觀眾老爺們能在評論區指出！

為什麼要學這個 Lambda 表示式？

  1. Java 8 的新特性，簡化程式碼的編寫。
  2. 工作中會用到，防止看不懂別人寫的程式碼。
  3. 大家都學我也學。

什麼是 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 關鍵字及語句分號。
    • 處理邏輯過於臃腫複雜，還是使用具體子類改寫較好，保證可讀性。

最後的最後

由本人水平所限，難免有錯誤以及不足之處， 螢幕前的靚仔靚女們 如有發現，懇請指出！

最後，謝謝你看到這裡，謝謝你認真對待我的努力，希望這篇部落格對你有所幫助！

你輕輕地點了個贊，那將在我的心裡世界增添一顆明亮而耀眼的星！

相關文章