《Java8 實戰》-第三章讀書筆記（Lambda 表達式-01）

Lambda 表達式

在《 Java8 實戰》中第三章主要講的是Lambda 表達式，在上一章節的筆記中咱們利用了行爲參數化來因對不斷變化的需求，最後咱們也使用到了 Lambda，經過表達式爲咱們簡化了不少代碼從而極大地提升了咱們的效率。那咱們就來更深刻的瞭解一下如何使用 Lambda 表達式，讓咱們的代碼更加具備簡潔性和易讀性。

Lambda 管中窺豹

什麼是 Lambda 表達式？簡單的來講，Lambda 表達式是一個匿名函數，Lambda 表達式基於數學中的λ演算得名，直接對應其中的 Lambda 抽象（ lambda abstraction ），是一個匿名函數，既沒有函數名的函數。Lambda 表達式能夠表示閉包（注意和數學傳統意義的不一樣）。你也能夠理解爲，簡潔的表示可傳遞的匿名函數的一種方式：它沒有名稱，但它有參數列表、函數主體、返回類型，可能還有一個能夠拋出異常的列表。

有時候，咱們爲了簡化代碼而去使用匿名類，雖然匿名類能簡化一部分代碼，可是看起來很囉嗦。爲了更好的的提升開發的效率以及代碼的簡潔性和可讀性，Java8 推出了一個核心的新特性之一：Lambda 表達式。

Java8 以前，使用匿名類給蘋果排序的代碼：

apples.sort(new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight().compareTo(o2.getWeight());
    }
});

是的，這段代碼看上去並非那麼的清晰明瞭，使用 Lambda 表達式改進後：

Comparator<Apple> byWeight = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

或者是：

Comparator<Apple> byWeight = Comparator.comparing(Apple::getWeight);

不得不認可，代碼看起來跟清晰了。要是你以爲 Lambda 表達式看起來一頭霧水的話也不要緊，咱們慢慢的來了解它。

如今，咱們來看看幾個 Java8 中有效的 Lambda 表達式加深對 Lambda 表達式的理解：

// 這個表達式具備一個 String 類型的參數並返回一個 int,Lambda 並無 return 語句,由於已經隱含了 return。
(String s) -> s.length() 

// 這個表達式有一個 Apple 類型的參數並返回一個 boolean （蘋果重來是否大於 150 克）
(Apple a) -> a.getWeight() > 150

// 這個表達式具備兩個 int 類型二的參數而且沒有返回值。Lambda 表達式能夠包含多行代碼，不僅是這兩行。
(int x, int y) -> {
    System.out.println("Result:");
    System.out.println(x + y);
}

// 這個表達式沒有參數類型，返回一個 int。
() -> 250

// 顯式的指定爲 Apple 類型，並對重量進行比較返回 int
(Apple a2, Apple a2) -> a1.getWeight.compareTo(a2.getWeight())

Java 語言設計者選選擇了這樣的語法，是由於 C#和 Scala 等語言中的相似功能廣受歡迎。Lambda 的基本語法是：

(parameters) -> expression

或者（請注意花括號）：

(parameters) -> {statements;}

是的，Lambda 表達式的語法看起來就是那麼簡單。那咱們繼續看幾個例子，看看如下哪幾個是有效的:

（ 1 ） () -> {}
（ 2 ） () -> "Jack"
（ 3 ） () -> {return "Jack"}
（ 4 ） (Interge i) -> return "Alan" + i;
（ 5 ） (String s) -> {"IronMan";}

正確答案是：(1)、(2)、(3)

緣由:

(1) 是一個無參而且無返回的，相似與 private void run() {}.

(2) 是一個無參而且返回的是一個字符串。

(3) 是一個無參，而且返回的是一個字符串，不過裏面還能夠繼續寫一些其餘的代碼（利用顯式返回語句）。

(4) 它沒有使用使用顯式返回語句，因此它不能算是一個表達式。想要有效就必須加一對花括號， (Interge i) -> {return "Alan" + i}

(5) "IronMan"很顯然是一個表達式，不是一個語句，去掉這一對花括號或者使用顯式返回語句便可有效。

在哪裏以及如何使用 Lambda

咱們剛剛已經看了不少關於 Lambda 表達式的語法例子，可能你還不太清楚這個 Lambda 表達式到底如何使用。

還記得在上一章的讀書筆記中，實現的 filter 方法中，咱們使用的就是 Lambda:

List<Apple> heavyApples = filter(apples, (Apple apple) -> apple.getWeight() > 150);

咱們能夠在函數式接口上使用 Lambda 表達式，函數式接口聽起來很抽象，可是不用太擔憂接下來就會解釋函數式接口是什麼。

函數式接口

還記得第二章中的讀書筆記，爲了參數化 filter 方法的行爲使用的 Predicate<t>接口嗎？它就是一個函數式接口。什麼是函數式接口?一言蔽之，函數式接口就是隻定義了一個抽象方法的接口。例如 JavaAPI 中的：Comparator、Runnable、Callable：</t>

public interface Comparable<T> {
    public int compareTo(T o);
}

public interface Runnable {
    public abstract void run();
}

public interface Callable<V> {
    V call() throws Exception;
}

固然，不僅是它們，還有不少一些其餘的函數式接口。

函數式接口到底能夠用來幹什麼？ Lambda 表達式容許你直接之內聯的形式爲函數式接口的抽象方法提供實例，並把整個表達式做爲函數式接口的實例（具體來講，是函數式接口一個具體實現的實例）。你也可使用匿名類實現，只不過看來並非那麼的一目瞭然。使用匿名類你須要提供一個實例，而後在直接內聯將它實例化。

經過下面的代碼，你能夠來比較一下使用函數式接口和使用匿名類的區別：

// 使用 Lambda 表達式
Runnable r1 = () -> System.out.println("HelloWorld 1");

// 使用匿名類
Runnable r2 = new Runnable() {
    @Override
    public void run() {
        System.out.println("HelloWorld 2");
    }
};

// 運行結果
System.out.println("Runnable 運行結果：");
// HelloWorld 1
process(r1);
// HelloWorld 2
process(r2);
// HelloWorld 3
process(() -> System.out.println("HelloWorld 3"));
        
private static void process(Runnable r) {
    r.run();
}

酷，從上面的代碼能夠看出使用 Lambda 表達式你能夠減小不少代碼同時也提升了代碼的可讀性而使用匿名類卻要四五行左右的代碼。

函數描述符

函數接口的抽象方法的前面基本上就是 Lambda 表達式的簽名。咱們將這種抽象方法叫作函數描述符。例如，Runnable 接口能夠看做一個什麼也不接受什麼也不返回的函數簽名，由於它只有一個叫作 run 的抽象方法，這個方法沒有參數而且是無返回的。

使用函數式接口

函數式接口頗有用，由於抽象方法的簽名能夠描述 Lambda 表達式的簽名。函數式接口的抽象方法的簽名稱爲函數描述符。

Predicate

在第一章的讀書筆記中，有提到過 Predicate 這個接口，如今咱們來詳細的瞭解一下它。

java.util.function.Predicate<t>接口定義了一個名字叫 test 的抽象方法，它接受泛型 T 對象，並返回一個 boolean 值。以前咱們是建立了一個 Predicate<t>這樣的一個接口，如今咱們所說到的這個接口和以前建立的同樣，如今咱們不須要再去建立一個這樣的接口就直接可使用了。在你須要表示一個涉及類型 T 的布爾表達式時，就可使用這個接口。好比，你能夠定義一個接受 String 對象的 Lambda 表達式：</t></t>

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

private static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.test(t)) {
            result.add(t);
        }
    }
    return result;
}

List<String> strings = Arrays.asList("Hello", "", "Java8", "", "In", "Action");
Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();

List<String> stringList = filter(strings, nonEmptyStringPredicate);
// [Hello, Java8, In, Action]
System.out.println(stringList);

若是，你去查看 Predicate 這個接口的源碼你會發現有一些 and 或者 or 等等一些其餘的方法，而且這個方法還有方法體，不過你目前無需關注這樣的方法，之後的文章將會介紹到爲何在接口中能定義有方法體的方法。

Consumer

java.util.function.Consumer<t>定義了一個叫作 accept 的抽象方法，它接受泛型 T 的對象，而且是一個無返回的方法。你若是須要訪問類型 T 的對象，並對其執行某些操做，就可使用這個接口。好比，你能夠用它來建立一個 foreach 方法，並配合 Lambda 來打印列表中的全部元素.</t>

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

private static <T> void forEach(List<T> list, Consumer<T> consumer) {
    for (T i : list) {
        consumer.accept(i);
    }
}

// 使用 Consumer
forEach(Arrays.asList("Object", "Not", "Found"), (String str) -> System.out.println(str));
forEach(Arrays.asList(1, 2, 3, 4, 5, 6), System.out::println);

Function

java.util.function.Function<T, R>接口定義了一個叫作 apply 的方法，它接受一個泛型 T 的對象，並返回一個泛型 R 的對象。若是你須要定義一個 Lambda，將輸入對象的信息映射到輸出，就可使用這個接口（好比提取蘋果的重量，把字符串映射爲它的長度）。在下面的代碼中，咱們來看看如何利用它來建立一個 map 方法，將以一個 String 列表映射到包含每一個 String 長度的 Integer 列表。

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

private static <T, R> List<R> map(List<T> list, Function<T, R> function) {
    List<R> result = new ArrayList<>();
    for (T s : list) {
        result.add(function.apply(s));
    }
    return result;
}

 List<Integer> map = map(Arrays.asList("lambdas", "in", "action"), (String s) -> s.length());
// [7, 2, 6]
System.out.println(map);

原始類型特化

咱們剛剛瞭解了三個泛型函數式接口：Predicate<t>、Consumer<t>和 Function<T, R>。還有些函數式接口專爲某些類而設計。</t></t>

回顧一下：Java 類型要麼用引用類型（好比：Byte、Integer、Object、List ），要麼是原始類型（好比：int、double、byte、char ）。可是泛型（好比 Consumer<t>中的 T ）只能綁定到引用類型。這是由泛型接口內部實現方式形成的。所以，在 Java 裏面有一個將原始類型轉爲對應的引用類型的機制。這個機制叫做裝箱（ boxing ）。相反的操做，也就是將引用類型轉爲對應的原始類型，叫做拆箱（ unboxing ）。Java 還有一個自動裝箱機制來幫助程序員執行這一任務：裝箱和拆箱操做都是自動完成的。好比，這就是爲何下面的代碼是有效的（一個 int 被裝箱成爲 Integer ）：</t>

List<Integer> list = new ArrayList<>;
for (int i = 0; i < 100; i++) {
    list.add(i);
}

可是像這種自動裝箱和拆箱的操做，性能方面是要付出一些代價的。裝箱的本質就是將原來的原始類型包起來，並保存在堆裏。所以，裝箱後的值須要更多的內存，並須要額外的內存搜索來獲取被包裹的原始值。

Java8 爲咱們前面所說的函數式接口帶來了一個專門的版本，以便在輸入和輸出都是原始類型時，避免自動裝箱的操做。好比，在下面的代碼中，使用 IntPredicate 就避免了對值 1000 進行裝箱操做，但要使用 Predicate<integer>就會把參數 1000 裝箱到一個 Integer 對象中：</integer>

@FunctionalInterface
public interface IntPredicate {
    boolean test(int value);
}

IntPredicate evenNumbers = (int i) -> i % 2 == 0;
// 無裝箱
evenNumbers.test(1000);

Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;
// 裝箱
oddNumbers.test(1000);

通常來講，針對專門的輸入參數類型的函數式接口的名稱都要加上對應的原始類型前綴，好比 DoublePredicate、IntConsumer、LongBinaryOperator、IntFunction 等。Function 接口還有針對輸出參數類型變種：ToIntFunction<t>、IntToDoubleFunction 等。</t>

Java8 中還有不少經常使用的函數式接口，若是你有興趣能夠去查找一些相關的資料，瞭解了這些經常使用的函數接口以後，會對你之後瞭解 Stream 的知識有很大的幫助。

代碼示例：

Github：chap3 Gitee: chap3