《回爐重造》——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 關鍵字及陳述句分號，
  • 處理邏輯過于臃腫復雜，還是使用具體子類改寫較好，保證可讀性，

最后的最后

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

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

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

標籤：Java

上一篇：redis對key和資料庫的基本操作

下一篇：day24-服務器端渲染技術02