1. 什么是λ表達式
λ表達式本質上是一個匿名方法。讓我們來看下面這個例子：
public int add(int x, int y) {
return x + y;
}
轉成λ表達式后是這個樣子：
(int x, int y) -> x + y;
參數類型也可以省略，Java編譯器會根據上下文推斷出來：
(x, y) -> x + y; //返回兩數之和
或者
(x, y) -> { return x + y; } //顯式指明返回值
可見λ表達式有三部分組成：參數列表，箭頭（->），以及一個表達式或語句塊。
下面這個例子里的λ表達式沒有參數，也沒有返回值（相當于一個方法接受0個參數，返回void，其實就是Runnable里run方法的一個實現）：
() -> { System.out.println("Hello Lambda!"); }
如果只有一個參數且可以被Java推斷出類型，那么參數列表的括號也可以省略：
c -> { return c.size(); }
2. λ表達式的類型（它是Object嗎？）
λ表達式可以被當做是一個Object（注意措辭）。λ表達式的類型，叫做“目標類型（target type）”。λ表達式的目標類型是“函數接口（functional interface）”，這是Java8新引入的概念。它的定義是：一個接口，如果只有一個顯式聲明的抽象方法，那么它就是一個函數接口。一般用@FunctionalInterface標注出來（也可以不標）。舉例如下：
@FunctionalInterface
public interface Runnable { void run(); }
public interface Callable { V call() throws Exception; }
public interface ActionListener { void actionPerformed(ActionEvent e); }
public interface Comparator { int compare(T o1, T o2); boolean equals(Object obj); }
注意最后這個Comparator接口。它里面聲明了兩個方法，貌似不符合函數接口的定義，但它的確是函數接口。這是因為equals方法是Object的，所有的接口都會聲明Object的public方法——雖然大多是隱式的。所以，Comparator顯式的聲明了equals不影響它依然是個函數接口。
你可以用一個λ表達式為一個函數接口賦值：
Runnable r1 = () -> {System.out.println("Hello Lambda!");};
然后再賦值給一個Object：
Object obj = r1;
但卻不能這樣干：
Object obj = () -> {System.out.println("Hello Lambda!");}; // ERROR! Object is not a functional interface!
必須顯式的轉型成一個函數接口才可以：
Object o = (Runnable) () -> { System.out.println("hi"); }; // correct
一個λ表達式只有在轉型成一個函數接口后才能被當做Object使用。所以下面這句也不能編譯：
System.out.println( () -> {} ); //錯誤! 目標類型不明
必須先轉型:
System.out.println( (Runnable)() -> {} ); // 正確
假設你自己寫了一個函數接口，長的跟Runnable一模一樣：
@FunctionalInterface
public interface MyRunnable {
public void run();
}
那么
Runnable r1 =??? () -> {System.out.println("Hello Lambda!");};
MyRunnable2 r2 = () -> {System.out.println("Hello Lambda!");};
都是正確的寫法。這說明一個λ表達式可以有多個目標類型（函數接口），只要函數匹配成功即可。
但需注意一個λ表達式必須至少有一個目標類型。
JDK預定義了很多函數接口以避免用戶重復定義。最典型的是Function：
@FunctionalInterface
public interface Function {
R apply(T t);
}
這個接口代表一個函數，接受一個T類型的參數，并返回一個R類型的返回值。
另一個預定義函數接口叫做Consumer，跟Function的唯一不同是它沒有返回值。
@FunctionalInterface
public interface Consumer {
void accept(T t);
}
還有一個Predicate，用來判斷某項條件是否滿足。經常用來進行篩濾操作：
@FunctionalInterface
public interface Predicate {
boolean test(T t);
}
綜上所述，一個λ表達式其實就是定義了一個匿名方法，只不過這個方法必須符合至少一個函數接口。
3. λ表達式的使用
3.1 λ表達式用在何處
λ表達式主要用于替換以前廣泛使用的內部匿名類，各種回調，比如事件響應器、傳入Thread類的Runnable等。看下面的例子：
Thread oldSchool = new Thread( new Runnable () {
@Override
public void run() {
System.out.println("This is from an anonymous class.");
}
} );
Thread gaoDuanDaQiShangDangCi = new Thread( () -> {
System.out.println("This is from an anonymous method (lambda exp).");
} );
注意第二個線程里的λ表達式，你并不需要顯式地把它轉成一個Runnable，因為Java能根據上下文自動推斷出來：一個Thread的構造函數接受一個Runnable參數，而傳入的λ表達式正好符合其run()函數，所以Java編譯器推斷它為Runnable。
從形式上看，λ表達式只是為你節省了幾行代碼。但將λ表達式引入Java的動機并不僅僅為此。Java8有一個短期目標和一個長期目標。短期目標是：配合“集合類批處理操作”的內部迭代和并行處理（下面將要講到）；長期目標是將Java向函數式編程語言這個方向引導（并不是要完全變成一門函數式編程語言，只是讓它有更多的函數式編程語言的特性），也正是由于這個原因，Oracle并沒有簡單地使用內部類去實現λ表達式，而是使用了一種更動態、更靈活、易于將來擴展和改變的策略（invokedynamic）。
3.2 λ表達式與集合類批處理操作（或者叫塊操作）
上文提到了集合類的批處理操作。這是Java8的另一個重要特性，它與λ表達式的配合使用乃是Java8的最主要特性。集合類的批處理操作API的目的是實現集合類的“內部迭代”，并期望充分利用現代多核CPU進行并行計算。
Java8之前集合類的迭代（Iteration）都是外部的，即客戶代碼。而內部迭代意味著改由Java類庫來進行迭代，而不是客戶代碼。例如：
for(Object o: list) { // 外部迭代
System.out.println(o);
}
可以寫成：
list.forEach(o -> {System.out.println(o);}); //forEach函數實現內部迭代
集合類（包括List）現在都有一個forEach方法，對元素進行迭代（遍歷），所以我們不需要再寫for循環了。forEach方法接受一個函數接口Consumer做參數，所以可以使用λ表達式。
這種內部迭代方法廣泛存在于各種語言，如C++的STL算法庫、Python、ruby、Scala等。
Java8為集合類引入了另一個重要概念：流（stream）。一個流通常以一個集合類實例為其數據源，然后在其上定義各種操作。流的API設計使用了管道（pipelines）模式。對流的一次操作會返回另一個流。如同IO的API或者StringBuffer的append方法那樣，從而多個不同的操作可以在一個語句里串起來。看下面的例子：
List shapes = ...
shapes.stream()
.filter(s -> s.getColor() == BLUE)
.forEach(s -> s.setColor(RED));
首先調用stream方法，以集合類對象shapes里面的元素為數據源，生成一個流。然后在這個流上調用filter方法，挑出藍色的，返回另一個流。最后調用forEach方法將這些藍色的物體噴成紅色。（forEach方法不再返回流，而是一個終端方法，類似于StringBuffer在調用若干append之后的那個toString）
filter方法的參數是Predicate類型，forEach方法的參數是Consumer類型，它們都是函數接口，所以可以使用λ表達式。
還有一個方法叫parallelStream()，顧名思義它和stream()一樣，只不過指明要并行處理，以期充分利用現代CPU的多核特性。
shapes.parallelStream(); // 或shapes.stream().parallel()
來看更多的例子。下面是典型的大數據處理方法，Filter-Map-Reduce：
//給出一個String類型的數組，找出其中所有不重復的素數
public void distinctPrimary(String... numbers) {
List l = Arrays.asList(numbers);
List r = l.stream()
.map(e -> new Integer(e))
.filter(e -> Primes.isPrime(e))
.distinct()
.collect(Collectors.toList());
System.out.println("distinctPrimary result is: " + r);
}
第一步：傳入一系列String（假設都是合法的數字），轉成一個List，然后調用stream()方法生成流。
第二步：調用流的map方法把每個元素由String轉成Integer，得到一個新的流。map方法接受一個Function類型的參數，上面介紹了，Function是個函數接口，所以這里用λ表達式。
第三步：調用流的filter方法，過濾那些不是素數的數字，并得到一個新流。filter方法接受一個Predicate類型的參數，上面介紹了，Predicate是個函數接口，所以這里用λ表達式。
第四步：調用流的distinct方法，去掉重復，并得到一個新流。這本質上是另一個filter操作。
第五步：用collect方法將最終結果收集到一個List里面去。collect方法接受一個Collector類型的參數，這個參數指明如何收集最終結果。在這個例子中，結果簡單地收集到一個List中。我們也可以用Collectors.toMap(e->e, e->e)把結果收集到一個Map中，它的意思是：把結果收到一個Map，用這些素數自身既作為鍵又作為值。toMap方法接受兩個Function類型的參數，分別用以生成鍵和值，Function是個函數接口，所以這里都用λ表達式。
你可能會覺得在這個例子里，List l被迭代了好多次，map，filter，distinct都分別是一次循環，效率會不好。實際并非如此。這些返回另一個Stream的方法都是“懶（lazy）”的，而最后返回最終結果的collect方法則是“急（eager）”的。在遇到eager方法之前，lazy的方法不會執行。
當遇到eager方法時，前面的lazy方法才會被依次執行。而且是管道貫通式執行。這意味著每一個元素依次通過這些管道。例如有個元素“3”，首先它被map成整數型3；然后通過filter，發現是素數，被保留下來；又通過distinct，如果已經有一個3了，那么就直接丟棄，如果還沒有則保留。這樣，3個操作其實只經過了一次循環。
除collect外其它的eager操作還有forEach，toArray，reduce等。
下面來看一下也許是最常用的收集器方法，groupingBy：
//給出一個String類型的數組，找出其中各個素數，并統計其出現次數
public void primaryOccurrence(String... numbers) {
List l = Arrays.asList(numbers);
Map r = l.stream()
.map(e -> new Integer(e))
.filter(e -> Primes.isPrime(e))
.collect( Collectors.groupingBy(p->p, Collectors.summingInt(p->1)) );
System.out.println("primaryOccurrence result is: " + r);
}
注意這一行：
Collectors.groupingBy(p->p, Collectors.summingInt(p->1))
它的意思是：把結果收集到一個Map中，用統計到的各個素數自身作為鍵，其出現次數作為值。
下面是一個reduce的例子：
//給出一個String類型的數組，求其中所有不重復素數的和
public void distinctPrimarySum(String... numbers) {
List l = Arrays.asList(numbers);
int sum = l.stream()
.map(e -> new Integer(e))
.filter(e -> Primes.isPrime(e))
.distinct()
.reduce(0, (x,y) -> x+y); // equivalent to .sum()
System.out.println("distinctPrimarySum result is: " + sum);
}
reduce方法用來產生單一的一個最終結果。
流有很多預定義的reduce操作，如sum()，max()，min()等。
再舉個現實世界里的栗子比如：
// 統計年齡在25-35歲的男女人數、比例
public void boysAndGirls(List persons) {
Map result = persons.parallelStream().filter(p -> p.getAge()>=25 && p.getAge()<=35).
collect(
Collectors.groupingBy(p->p.getSex(), Collectors.summingInt(p->1))
);
System.out.print("boysAndGirls result is " + result);
System.out.println(", ratio (male : female) is " + (float)result.get(Person.MALE)/result.get(Person.FEMALE));
}
3.3 λ表達式的更多用法
// 嵌套的λ表達式
Callable c1 = () -> () -> { System.out.println("Nested lambda"); };
c1.call().run();
// 用在條件表達式中
Callable c2 = true ? (() -> 42) : (() -> 24);
System.out.println(c2.call());
// 定義一個遞歸函數，注意須用this限定
protected UnaryOperator factorial = i -> i == 0 ? 1 : i * this.factorial.apply( i - 1 );
...
System.out.println(factorial.apply(3));
在Java中，隨聲明隨調用的方式是不行的，比如下面這樣，聲明了一個λ表達式(x, y) -> x + y，同時企圖通過傳入實參(2, 3)來調用它：
int five = ( (x, y) -> x + y ) (2, 3); // ERROR! try to call a lambda in-place
這在C++中是可以的，但Java中不行。Java的λ表達式只能用作賦值、傳參、返回值等。
4. 其它相關概念
4.1 捕獲（Capture）
捕獲的概念在于解決在λ表達式中我們可以使用哪些外部變量（即除了它自己的參數和內部定義的本地變量）的問題。
答案是：與內部類非常相似，但有不同點。不同點在于內部類總是持有一個其外部類對象的引用。而λ表達式呢，除非在它內部用到了其外部類（包圍類）對象的方法或者成員，否則它就不持有這個對象的引用。
在Java8以前，如果要在內部類訪問外部對象的一個本地變量，那么這個變量必須聲明為final才行。在Java8中，這種限制被去掉了，代之以一個新的概念，“effectively final”。它的意思是你可以聲明為final，也可以不聲明final但是按照final來用，也就是一次賦值永不改變。換句話說，保證它加上final前綴后不會出編譯錯誤。
在Java8中，內部類和λ表達式都可以訪問effectively final的本地變量。λ表達式的例子如下：
...
int tmp1 = 1; //包圍類的成員變量
static int tmp2 = 2; //包圍類的靜態成員變量
public void testCapture() {
int tmp3 = 3; //沒有聲明為final，但是effectively final的本地變量
final int tmp4 = 4; //聲明為final的本地變量
int tmp5 = 5; //普通本地變量
Function f1 = i -> i + tmp1;
Function f2 = i -> i + tmp2;
Function f3 = i -> i + tmp3;
Function f4 = i -> i + tmp4;
Function f5 = i -> {
tmp5? += i; // 編譯錯！對tmp5賦值導致它不是effectively final的
return tmp5;
};
...
tmp5 = 9; // 編譯錯！對tmp5賦值導致它不是effectively final的
}
...
Java要求本地變量final或者effectively final的原因是多線程并發問題。內部類、λ表達式都有可能在不同的線程中執行，允許多個線程同時修改一個本地變量不符合Java的設計理念。
4.2 方法引用（Method reference）
任何一個λ表達式都可以代表某個函數接口的唯一方法的匿名描述符。我們也可以使用某個類的某個具體方法來代表這個描述符，叫做方法引用。例如：
Integer::parseInt //靜態方法引用
System.out::print //實例方法引用
Person::new?????? //構造器引用
下面是一組例子，教你使用方法引用代替λ表達式：
//c1 與 c2 是一樣的（靜態方法引用）
Comparator c2 = (x, y) -> Integer.compare(x, y);
Comparator c1 = Integer::compare;
//下面兩句是一樣的（實例方法引用1）
persons.forEach(e -> System.out.println(e));
persons.forEach(System.out::println);
//下面兩句是一樣的（實例方法引用2）
persons.forEach(person -> person.eat());
persons.forEach(Person::eat);
//下面兩句是一樣的（構造器引用）
strList.stream().map(s -> new Integer(s));
strList.stream().map(Integer::new);
使用方法引用，你的程序會變得更短些。現在distinctPrimarySum方法可以改寫如下：
public void distinctPrimarySum(String... numbers) {
List l = Arrays.asList(numbers);
int sum = l.stream().map(Integer::new).filter(Primes::isPrime).distinct().sum();
System.out.println("distinctPrimarySum result is: " + sum);
}
還有一些其它的方法引用:
super::toString //引用某個對象的父類方法
String[]::new //引用一個數組的構造器
4.3 默認方法（Default method）
Java8中，接口聲明里可以有方法實現了，叫做默認方法。在此之前，接口里的方法全部是抽象方法。
public interface MyInterf {
String m1();
default String m2() {
return "Hello default method!";
}
}
這實際上混淆了接口和抽象類，但一個類仍然可以實現多個接口，而只能繼承一個抽象類。
這么做的原因是：由于Collection庫需要為批處理操作添加新的方法，如forEach()，stream()等，但是不能修改現有的Collection接口——如果那樣做的話所有的實現類都要進行修改，包括很多客戶自制的實現類。所以只好使用這種妥協的辦法。
如此一來，我們就面臨一種類似多繼承的問題。如果類Sub繼承了兩個接口，Base1和Base2，而這兩個接口恰好具有完全相同的兩個默認方法，那么就會產生沖突。這時Sub類就必須通過重載來顯式指明自己要使用哪一個接口的實現（或者提供自己的實現）：
public class Sub implements Base1, Base2 {
public void hello() {
Base1.super.hello(); //使用Base1的實現
}
}
除了默認方法，Java8的接口也可以有靜態方法的實現：
public interface MyInterf {
String m1();
default String m2() {
return "Hello default method!";
}
static String m3() {
return "Hello static method in Interface!";
}
}
4.4 生成器函數（Generator function）
有時候一個流的數據源不一定是一個已存在的集合對象，也可能是個“生成器函數”。一個生成器函數會產生一系列元素，供給一個流。Stream.generate(Supplier s)就是一個生成器函數。其中參數Supplier是一個函數接口，里面有唯一的抽象方法 get()。
下面這個例子生成并打印5個隨機數：
Stream.generate(Math::random).limit(5).forEach(System.out::println);
注意這個limit(5)，如果沒有這個調用，那么這條語句會永遠地執行下去。也就是說這個生成器是無窮的。這種調用叫做終結操作，或者短路（short-circuiting）操作。
