摘要：之前，使用匿名類給蘋果排序的代碼是的，這段代碼看上去并不是那么的清晰明了，使用表達式改進后或者是不得不承認，代碼看起來跟清晰了。這是由泛型接口內部實現方式造成的。

# Lambda表達式
在《Java8實戰》中第三章主要講的是Lambda表達式，在上一章節的筆記中我們利用了行為參數化來因對不斷變化的需求，最后我們也使用到了Lambda，通過表達式為我們簡化了很多代碼從而極大地提高了我們的效率。那我們就來更深入的了解一下如何使用Lambda表達式，讓我們的代碼更加具有簡潔性和易讀性。

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

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

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

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

是的，這段代碼看上去并不是那么的清晰明了，使用Lambda表達式改進后：

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

或者是：

Comparator 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表達式到底如何使用。

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

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

我們可以在函數式接口上使用Lambda表達式，函數式接口聽起來很抽象，但是不用太擔心接下來就會解釋函數式接口是什么。

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

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

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

public interface Callable {
    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這個接口，現在我們來詳細的了解一下它。

java.util.function.Predicate接口定義了一個名字叫test的抽象方法，它接受泛型T對象，并返回一個boolean值。之前我們是創建了一個Predicate這樣的一個接口，現在我們所說到的這個接口和之前創建的一樣，現在我們不需要再去創建一個這樣的接口就直接可以使用了。在你需要表示一個涉及類型T的布爾表達式時，就可以使用這個接口。比如，你可以定義一個接受String對象的Lambda表達式：

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

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

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

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

如果，你去查看Predicate這個接口的源碼你會發現有一些and或者or等等一些其他的方法，并且這個方法還有方法體，不過你目前無需關注這樣的方法，以后的文章將會介紹到為什么在接口中能定義有方法體的方法。

java.util.function.Consumer定義了一個叫做accept的抽象方法，它接受泛型T的對象，并且是一個無返回的方法。你如果需要訪問類型T的對象，并對其執行某些操作，就可以使用這個接口。比如，你可以用它來創建一個foreach方法，并配合Lambda來打印列表中的所有元素.

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

private static  void forEach(List list, Consumer 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);

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

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

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

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

原始類型特化

我們剛剛了解了三個泛型函數式接口：Predicate、Consumer和Function。還有些函數式接口專為某些類而設計。

回顧一下：Java類型要么用引用類型（比如：Byte、Integer、Object、List），要么是原始類型（比如：int、double、byte、char）。但是泛型（比如Consumer中的T）只能綁定到引用類型。這是由泛型接口內部實現方式造成的。因此，在Java里面有一個將原始類型轉為對應的引用類型的機制。這個機制叫作裝箱（boxing）。相反的操作，也就是將引用類型轉為對應的原始類型，叫作拆箱（unboxing）。Java還有一個自動裝箱機制來幫助程序員執行這一任務：裝箱和拆箱操作都是自動完成的。比如，這就是為什么下面的代碼是有效的（一個int被裝箱成為Integer）：

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

但是像這種自動裝箱和拆箱的操作，性能方面是要付出一些代價的。裝箱的本質就是將原來的原始類型包起來，并保存在堆里。因此，裝箱后的值需要更多的內存，并需要額外的內存搜索來獲取被包裹的原始值。

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

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

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

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

一般來說，針對專門的輸入參數類型的函數式接口的名稱都要加上對應的原始類型前綴，比如DoublePredicate、IntConsumer、LongBinaryOperator、IntFunction等。Function接口還有針對輸出參數類型變種：ToIntFunction、IntToDoubleFunction等。

Java8中還有很多常用的函數式接口，如果你有興趣可以去查找一些相關的資料，了解了這些常用的函數接口之后，會對你以后了解Stream的知識有很大的幫助。

《Java8實戰》這本書第三章的內容很多，所以我打算分兩篇文章來寫。這些讀書筆記系列的文章內容很多地方都是借鑒書中的內容。如果您有時間、興趣和經濟的話可以去買這本書籍。這本書我看了兩遍，是一本很不錯的技術書籍。如果，您沒有太多的時間那么您就可以關注我的微信公眾號或者當前的技術社區的賬號，利用空閑的時間看看我的文章，非常感謝您對我的關注！

Github：chap3

Gitee: chap3