博客 / 詳情

返回

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

前言

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

最後的最後

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

最後，謝謝你看到這裏，謝謝你認真對待我的努力，希望這篇博客對你有所幫助！

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

匿名函數 , lambda , 匿名內部類 , JAVA , 後端
user avatar
0 位用戶收藏了這個故事！

發佈 評論

Some HTML is okay.