是的，這個(gè)問(wèn)題問(wèn)得很好，先保持這個(gè)疑問(wèn)！在回答這個(gè)問(wèn)題之前，我先來(lái)說(shuō)說(shuō)另一個(gè)概念——「函數(shù)式編程」。

什么是函數(shù)式編程？

函數(shù)式編程是一種編程范式，除此之外，還有聲明式編程、命令式編程，也都是編程范式。

好吧，這里又扯出一個(gè)新的專業(yè)名詞——「編程范式（Programming Paradigm）」。范式？相信正在閱讀的你，在學(xué)習(xí)數(shù)據(jù)庫(kù)知識(shí)的時(shí)候，肯定學(xué)過(guò)第一范式、第二范式、第三范式，那現(xiàn)在又有一個(gè)編程范式，這是什么鬼？

百度百科是這樣說(shuō)的：

編程范型、編程范式或程序設(shè)計(jì)法（英語(yǔ)：Programming paradigm），（范即模范、典范之意，范式即模式、方法），是一類典型的編程風(fēng)格，是指從事軟件工程的一類典型的風(fēng)格（可以對(duì)照方法學(xué)）。如：函數(shù)式編程、程序編程、面向?qū)ο缶幊?/a>、指令式編程等等為不同的編程范型。

是不是太官方了，沒(méi)關(guān)系，簡(jiǎn)單理解，我認(rèn)為知道函數(shù)式編程是一種寫代碼時(shí)的風(fēng)格就OK了。

我們需要注意的是，函數(shù)式編程中的「函數(shù)」二字，是數(shù)學(xué)上的函數(shù)，并不是我們現(xiàn)在習(xí)慣理解的函數(shù)，也就是說(shuō)，這是純純數(shù)學(xué)概念上的函數(shù)，即自變量的映射，比如 <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><annotation encoding="application/x-tex">y = f(x)</annotation></semantics></math>y=f(x)，自變量 <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><annotation encoding="application/x-tex">x</annotation></semantics></math>x，通過(guò)函數(shù) <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><annotation encoding="application/x-tex">f</annotation></semantics></math>f 映射成 <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><annotation encoding="application/x-tex">y</annotation></semantics></math>y 。

函數(shù)式編程和 Lambda 表達(dá)式有什么關(guān)系？

可以說(shuō)，函數(shù)式編程允許使用一種表達(dá)式來(lái)表示一個(gè)函數(shù)，這種表達(dá)式就是 Lambda 表達(dá)式。

在 Java 中，函數(shù)式編程是通過(guò)一個(gè)接口規(guī)范來(lái)實(shí)現(xiàn)的，接口具有這種特點(diǎn)：

• 該接口有且只有一個(gè)抽象方法
• 該接口使用 @FunctionalInterface 注解進(jìn)行標(biāo)識(shí)

具有這個(gè)特點(diǎn)的接口稱為「函數(shù)式接口」。

現(xiàn)在，回到最開(kāi)始說(shuō)的，「沒(méi)有函數(shù)名，那我怎么調(diào)用這個(gè)函數(shù)?。俊?，這就是函數(shù)式接口的用途了，接口中只有一個(gè)抽象方法，不用指定方法名稱，就能夠用 Lambda 表達(dá)式來(lái)調(diào)用這個(gè)函數(shù)（方法）了，不需要知道函數(shù)名就能夠?qū)崿F(xiàn)調(diào)用。好比想在某個(gè)房間（接口）找個(gè)人（方法）來(lái)做事，我這個(gè)房間只有一個(gè)人，那么除了這個(gè)人，沒(méi)有其他人可以來(lái)做事了，就不需要指定那誰(shuí)誰(shuí)誰(shuí)過(guò)來(lái)幫忙，而是直接喊：就決定是你了！（這個(gè)比喻可能也不是很恰當(dāng)，當(dāng)大概意思是這樣哈哈哈）

函數(shù)式接口

Comparator

我們可以看看 Comparator 接口，它有 @FunctionalInterface注解，那么可以肯定它是一個(gè)函數(shù)式接口。

@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);
        };
    }
    ...
}
復(fù)制代碼

有小伙伴應(yīng)該要說(shuō)了，這個(gè)接口這么多方法，為什么還能是函數(shù)式接口？

注意了啊，我們可以看到一個(gè)好像是抽象的 equals 方法，但是，因?yàn)?equals 是 Object 中的方法，這種對(duì)Object 類的方法的重新聲明是會(huì)讓方法變成一個(gè)具體的方法。所以，不要誤會(huì)了，這里的抽象方法就只有 compare 方法。

那可能有小伙伴要說(shuō)了，接口中還能有具體的方法？

是的，沒(méi)錯(cuò)，在 Java 8 中，接口中可以寫具體的方法了。比如上面的 reversed 和 thenComparing 方法，都是具體的方法。

常見(jiàn)的函數(shù)式接口

• java.lang.Runnable

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
復(fù)制代碼

• java.util.concurrent.Callable

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}
復(fù)制代碼

• java.lang.reflect.InvocationHandler

@FunctionalInterface
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}
復(fù)制代碼

如何使用 Lambda 表達(dá)式？

在 Java 8 之前，我們使用 Collections 的需要比較器的 sort 方法，是這樣的。

等等，忘了有比較器參數(shù)的 sort 方法了？沒(méi)關(guān)系，代碼給你貼上：

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}
復(fù)制代碼

最開(kāi)始的寫法是這樣的，由于 Comparator 是一個(gè)接口，不能直接實(shí)例化，所以需要一個(gè)類來(lái)實(shí)現(xiàn)這個(gè)接口作為真正的比較器類，然后將這個(gè) Comparator 實(shí)例對(duì)象作為 sort 方法第二個(gè)參數(shù)傳入，實(shí)現(xiàn)排序，如下：

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]
復(fù)制代碼

后來(lái)，這種寫法比較麻煩，于是用匿名內(nèi)部類改寫這種寫法，我們不需要自己去編寫一個(gè)類來(lái)實(shí)現(xiàn)這個(gè)接口了，直接用匿名內(nèi)部類。就是這種寫法：

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]
復(fù)制代碼

現(xiàn)在，匿名內(nèi)部類比起 Lambda 表達(dá)式，也是麻煩，我們用 Lambda 進(jìn)行改寫：

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]
復(fù)制代碼

是吧，(Integer v1, Integer v2) -> {return v1 - v2;} 的寫法，沒(méi)有函數(shù)名，也能進(jìn)行調(diào)用。

實(shí)際上，這樣還不是最簡(jiǎn)的，最簡(jiǎn)的是這樣：(v1, v2) -> v1 - v2

是不是很好奇啥時(shí)候能這樣寫？現(xiàn)在就告訴你！

基本語(yǔ)法

(參數(shù)類型 參數(shù)名) -> { 方法體 }

基本上，這樣寫，是不會(huì)有問(wèn)題的。下面說(shuō)說(shuō)何時(shí)能寫得更加簡(jiǎn)單。

為了便于閱讀，下面的「方法」指的是函數(shù)式接口中的抽象方法

• 方法沒(méi)有參數(shù)，那么可以直接寫小括號(hào)，然后箭頭，再寫中括號(hào)，最后寫方法體，即 () -> { 方法體 }
• 方法有多個(gè)參數(shù)，那么多個(gè)參數(shù)就用逗號(hào)分開(kāi)，同時(shí)參數(shù)類型是可以省略的，即 (v1, v2, ...) -> {方法體}
• 方法只有一個(gè)參數(shù)，那么小括號(hào)可以去掉，直接寫參數(shù)名，然后箭頭，再中括號(hào)和方法體，即 v -> {方法體}
• 方法體只有一條語(yǔ)句，無(wú)論是否有返回值，都可以省略大括號(hào)、return 關(guān)鍵字及語(yǔ)句分號(hào)。

情況一：方法無(wú)參數(shù)、無(wú)返回值

常見(jiàn)的就是 Runnable 接口了。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
復(fù)制代碼

• 未使用 Lambda（使用匿名內(nèi)部類）：

new Thread(new Runnable() {
    @Override
    void run() {
        System.out.println("線程開(kāi)始跑了");
    }
}).start();
復(fù)制代碼

• 使用 Lambda：

// 寫法一
new Thread(() -> {
    System.out.println("線程開(kāi)始跑了")
}).start();
// 寫法二，一條語(yǔ)句，那么省略大括號(hào)、return 關(guān)鍵字及語(yǔ)句分號(hào)
new Thread(() -> System.out.println("線程開(kāi)始跑了")).start();
復(fù)制代碼

情況二：方法無(wú)參數(shù)，有返回值

例子：Callable 接口

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}
復(fù)制代碼

• 未使用 Lambda（使用匿名內(nèi)部類）：

FutureTask<String> stringFutureTask = new FutureTask<>(new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "這里是返回值";
    }
});
stringFutureTask.run();
System.out.println(stringFutureTask.get());
復(fù)制代碼

• 使用 Lambda：

// 一條語(yǔ)句，省略大括號(hào)、return 關(guān)鍵字及語(yǔ)句分號(hào)
FutureTask<String> stringFutureTask = new FutureTask<>(() -> "這里是返回值");
stringFutureTask.run();
System.out.println(stringFutureTask.get());
復(fù)制代碼

情況三：方法一個(gè)參數(shù)、有返回值

我隨便找了 JDK 中的一個(gè)接口，如下：

@FunctionalInterface
interface Recognizer {
    boolean recognize(int c);
}
復(fù)制代碼

• 未使用 Lambda（使用匿名內(nèi)部類）：

private final Recognizer A = new Recognizer() {
    @Override
    public boolean recognize(int c) {
        return c == 'a' || c == 'A';
    }
}
復(fù)制代碼

• 使用 Lambda：

private final Recognizer A = (c) -> c == 'a' || c == 'A';

// 一個(gè)參數(shù)，可省略小括號(hào)
private final Recognizer A = c -> c == 'a' || c == 'A';
復(fù)制代碼

情況四：方法多個(gè)參數(shù)、有返回值

直接舉 Comparator 這個(gè)例子。

• 未使用 Lambda（使用匿名內(nèi)部類）：

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;
    }
});
復(fù)制代碼

• 使用 Lambda：

List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
// 多個(gè)參數(shù)以逗號(hào)分開(kāi)，可省略類型，一條語(yǔ)句，省略大括號(hào)、return 關(guān)鍵字及語(yǔ)句分號(hào)
keys.sort((v1, v2) -> v1 - v2);
System.out.println(keys);
復(fù)制代碼

總結(jié)

到這里，相信大家對(duì)于 Lambda 表達(dá)式有了一個(gè)基本的認(rèn)識(shí)?？偟膩?lái)說(shuō)：

• 必須是函數(shù)式接口才能使用 Lambda 表達(dá)式

語(yǔ)法：(參數(shù)類型 參數(shù)名稱) ‐> { 方法體 }

• 若方法的參數(shù)列表：
  • 沒(méi)有參數(shù)，則可直接用 () ；
  • 有一個(gè)參數(shù)，可以省略 ()，直接寫參數(shù)；
  • 有多個(gè)參數(shù)，則()不可省略
  • () 內(nèi)的參數(shù)類型可以省略
• 若方法體：
  • 只有一條語(yǔ)句，無(wú)論是否有返回值，都可以省略大括號(hào)、return 關(guān)鍵字及語(yǔ)句分號(hào)。
  • 處理邏輯過(guò)于臃腫復(fù)雜，還是使用具體子類改寫較好，保證可讀性。

最后的最后

由本人水平所限，難免有錯(cuò)誤以及不足之處， 屏幕前的靚仔靚女們 如有發(fā)現(xiàn)，懇請(qǐng)指出！

最后，謝謝你看到這里，謝謝你認(rèn)真對(duì)待我的努力，希望這篇博客對(duì)你有所幫助！

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