1. 什么是λ表達(dá)式
λ表達(dá)式本質(zhì)上是一個(gè)匿名方法蛛芥。讓我們來看下面這個(gè)例子：
public int add(int x, int y) {
return x + y;
}
轉(zhuǎn)成λ表達(dá)式后是這個(gè)樣子：
(int x, int y) -> x + y;
參數(shù)類型也可以省略洗鸵，Java編譯器會(huì)根據(jù)上下文推斷出來：
(x, y) -> x + y; //返回兩數(shù)之和
或者
(x, y) -> { return x + y; } //顯式指明返回值
可見λ表達(dá)式有三部分組成：參數(shù)列表，箭頭（->）绍些，以及一個(gè)表達(dá)式或語句塊。
下面這個(gè)例子里的λ表達(dá)式?jīng)]有參數(shù)耀鸦，也沒有返回值（相當(dāng)于一個(gè)方法接受0個(gè)參數(shù)柬批，返回void，其實(shí)就是Runnable里run方法的一個(gè)實(shí)現(xiàn)）：
() -> { System.out.println("Hello Lambda!"); }
如果只有一個(gè)參數(shù)且可以被Java推斷出類型袖订，那么參數(shù)列表的括號(hào)也可以省略：
c -> { return c.size(); }
2. λ表達(dá)式的類型（它是Object嗎氮帐？）
λ表達(dá)式可以被當(dāng)做是一個(gè)Object（注意措辭）。λ表達(dá)式的類型洛姑，叫做“目標(biāo)類型（target type）”揪漩。λ表達(dá)式的目標(biāo)類型是“函數(shù)接口（functional interface）”，這是Java8新引入的概念吏口。它的定義是：一個(gè)接口奄容，如果只有一個(gè)顯式聲明的抽象方法，那么它就是一個(gè)函數(shù)接口产徊。一般用@FunctionalInterface標(biāo)注出來（也可以不標(biāo)）昂勒。舉例如下：
@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); }
注意最后這個(gè)Comparator接口。它里面聲明了兩個(gè)方法舟铜，貌似不符合函數(shù)接口的定義戈盈，但它的確是函數(shù)接口。這是因?yàn)閑quals方法是Object的谆刨，所有的接口都會(huì)聲明Object的public方法——雖然大多是隱式的塘娶。所以，Comparator顯式的聲明了equals不影響它依然是個(gè)函數(shù)接口痊夭。
你可以用一個(gè)λ表達(dá)式為一個(gè)函數(shù)接口賦值：
Runnable r1 = () -> {System.out.println("Hello Lambda!");};
然后再賦值給一個(gè)Object：
Object obj = r1;
但卻不能這樣干：
Object obj = () -> {System.out.println("Hello Lambda!");}; // ERROR! Object is not a functional interface!
必須顯式的轉(zhuǎn)型成一個(gè)函數(shù)接口才可以：
Object o = (Runnable) () -> { System.out.println("hi"); }; // correct
一個(gè)λ表達(dá)式只有在轉(zhuǎn)型成一個(gè)函數(shù)接口后才能被當(dāng)做Object使用刁岸。所以下面這句也不能編譯：
System.out.println( () -> {} ); //錯(cuò)誤! 目標(biāo)類型不明
必須先轉(zhuǎn)型:
System.out.println( (Runnable)() -> {} ); // 正確
假設(shè)你自己寫了一個(gè)函數(shù)接口，長(zhǎng)的跟Runnable一模一樣：
@FunctionalInterface
public interface MyRunnable {
public void run();
}
那么
Runnable r1 =??? () -> {System.out.println("Hello Lambda!");};
MyRunnable2 r2 = () -> {System.out.println("Hello Lambda!");};
都是正確的寫法她我。這說明一個(gè)λ表達(dá)式可以有多個(gè)目標(biāo)類型（函數(shù)接口）虹曙，只要函數(shù)匹配成功即可迫横。
但需注意一個(gè)λ表達(dá)式必須至少有一個(gè)目標(biāo)類型。
JDK預(yù)定義了很多函數(shù)接口以避免用戶重復(fù)定義酝碳。最典型的是Function：
@FunctionalInterface
public interface Function {
R apply(T t);
}
這個(gè)接口代表一個(gè)函數(shù)矾踱，接受一個(gè)T類型的參數(shù)，并返回一個(gè)R類型的返回值疏哗。
另一個(gè)預(yù)定義函數(shù)接口叫做Consumer呛讲，跟Function的唯一不同是它沒有返回值。
@FunctionalInterface
public interface Consumer {
void accept(T t);
}
還有一個(gè)Predicate返奉，用來判斷某項(xiàng)條件是否滿足圣蝎。經(jīng)常用來進(jìn)行篩濾操作：
@FunctionalInterface
public interface Predicate {
boolean test(T t);
}
綜上所述，一個(gè)λ表達(dá)式其實(shí)就是定義了一個(gè)匿名方法衡瓶，只不過這個(gè)方法必須符合至少一個(gè)函數(shù)接口徘公。
3. λ表達(dá)式的使用
3.1 λ表達(dá)式用在何處
λ表達(dá)式主要用于替換以前廣泛使用的內(nèi)部匿名類，各種回調(diào)哮针，比如事件響應(yīng)器关面、傳入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).");
} );
注意第二個(gè)線程里的λ表達(dá)式等太，你并不需要顯式地把它轉(zhuǎn)成一個(gè)Runnable，因?yàn)镴ava能根據(jù)上下文自動(dòng)推斷出來：一個(gè)Thread的構(gòu)造函數(shù)接受一個(gè)Runnable參數(shù)蛮放，而傳入的λ表達(dá)式正好符合其run()函數(shù)缩抡，所以Java編譯器推斷它為Runnable。
從形式上看包颁，λ表達(dá)式只是為你節(jié)省了幾行代碼瞻想。但將λ表達(dá)式引入Java的動(dòng)機(jī)并不僅僅為此。Java8有一個(gè)短期目標(biāo)和一個(gè)長(zhǎng)期目標(biāo)娩嚼。短期目標(biāo)是：配合“集合類批處理操作”的內(nèi)部迭代和并行處理（下面將要講到）蘑险；長(zhǎng)期目標(biāo)是將Java向函數(shù)式編程語言這個(gè)方向引導(dǎo)（并不是要完全變成一門函數(shù)式編程語言，只是讓它有更多的函數(shù)式編程語言的特性）岳悟，也正是由于這個(gè)原因佃迄，Oracle并沒有簡(jiǎn)單地使用內(nèi)部類去實(shí)現(xiàn)λ表達(dá)式，而是使用了一種更動(dòng)態(tài)贵少、更靈活呵俏、易于將來擴(kuò)展和改變的策略（invokedynamic）。
3.2 λ表達(dá)式與集合類批處理操作（或者叫塊操作）
上文提到了集合類的批處理操作滔灶。這是Java8的另一個(gè)重要特性普碎，它與λ表達(dá)式的配合使用乃是Java8的最主要特性。集合類的批處理操作API的目的是實(shí)現(xiàn)集合類的“內(nèi)部迭代”宽气，并期望充分利用現(xiàn)代多核CPU進(jìn)行并行計(jì)算随常。
Java8之前集合類的迭代（Iteration）都是外部的，即客戶代碼萄涯。而內(nèi)部迭代意味著改由Java類庫(kù)來進(jìn)行迭代绪氛，而不是客戶代碼。例如：
for(Object o: list) { // 外部迭代
System.out.println(o);
}
可以寫成：
list.forEach(o -> {System.out.println(o);}); //forEach函數(shù)實(shí)現(xiàn)內(nèi)部迭代
集合類（包括List）現(xiàn)在都有一個(gè)forEach方法涝影，對(duì)元素進(jìn)行迭代（遍歷）枣察，所以我們不需要再寫for循環(huán)了。forEach方法接受一個(gè)函數(shù)接口Consumer做參數(shù)燃逻，所以可以使用λ表達(dá)式序目。
這種內(nèi)部迭代方法廣泛存在于各種語言，如C++的STL算法庫(kù)伯襟、Python猿涨、ruby、Scala等姆怪。
Java8為集合類引入了另一個(gè)重要概念：流（stream）叛赚。一個(gè)流通常以一個(gè)集合類實(shí)例為其數(shù)據(jù)源，然后在其上定義各種操作稽揭。流的API設(shè)計(jì)使用了管道（pipelines）模式俺附。對(duì)流的一次操作會(huì)返回另一個(gè)流。如同IO的API或者StringBuffer的append方法那樣溪掀，從而多個(gè)不同的操作可以在一個(gè)語句里串起來事镣。看下面的例子：
List shapes = ...
shapes.stream()
.filter(s -> s.getColor() == BLUE)
.forEach(s -> s.setColor(RED));
首先調(diào)用stream方法揪胃，以集合類對(duì)象shapes里面的元素為數(shù)據(jù)源璃哟，生成一個(gè)流。然后在這個(gè)流上調(diào)用filter方法喊递，挑出藍(lán)色的沮稚，返回另一個(gè)流。最后調(diào)用forEach方法將這些藍(lán)色的物體噴成紅色册舞。（forEach方法不再返回流蕴掏，而是一個(gè)終端方法，類似于StringBuffer在調(diào)用若干append之后的那個(gè)toString）
filter方法的參數(shù)是Predicate類型调鲸，forEach方法的參數(shù)是Consumer類型，它們都是函數(shù)接口藐石，所以可以使用λ表達(dá)式即供。
還有一個(gè)方法叫parallelStream()，顧名思義它和stream()一樣于微，只不過指明要并行處理逗嫡，以期充分利用現(xiàn)代CPU的多核特性青自。
shapes.parallelStream(); // 或shapes.stream().parallel()
來看更多的例子。下面是典型的大數(shù)據(jù)處理方法驱证，F(xiàn)ilter-Map-Reduce：
//給出一個(gè)String類型的數(shù)組延窜，找出其中所有不重復(fù)的素?cái)?shù)
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（假設(shè)都是合法的數(shù)字），轉(zhuǎn)成一個(gè)List抹锄，然后調(diào)用stream()方法生成流逆瑞。
第二步：調(diào)用流的map方法把每個(gè)元素由String轉(zhuǎn)成Integer，得到一個(gè)新的流伙单。map方法接受一個(gè)Function類型的參數(shù)获高，上面介紹了，F(xiàn)unction是個(gè)函數(shù)接口吻育，所以這里用λ表達(dá)式念秧。
第三步：調(diào)用流的filter方法，過濾那些不是素?cái)?shù)的數(shù)字，并得到一個(gè)新流。filter方法接受一個(gè)Predicate類型的參數(shù)芬萍，上面介紹了垃环，Predicate是個(gè)函數(shù)接口，所以這里用λ表達(dá)式。
第四步：調(diào)用流的distinct方法，去掉重復(fù)，并得到一個(gè)新流梢为。這本質(zhì)上是另一個(gè)filter操作。
第五步：用collect方法將最終結(jié)果收集到一個(gè)List里面去轰坊。collect方法接受一個(gè)Collector類型的參數(shù)铸董，這個(gè)參數(shù)指明如何收集最終結(jié)果。在這個(gè)例子中肴沫，結(jié)果簡(jiǎn)單地收集到一個(gè)List中粟害。我們也可以用Collectors.toMap(e->e, e->e)把結(jié)果收集到一個(gè)Map中，它的意思是：把結(jié)果收到一個(gè)Map颤芬，用這些素?cái)?shù)自身既作為鍵又作為值悲幅。toMap方法接受兩個(gè)Function類型的參數(shù)，分別用以生成鍵和值站蝠，F(xiàn)unction是個(gè)函數(shù)接口汰具，所以這里都用λ表達(dá)式。
你可能會(huì)覺得在這個(gè)例子里菱魔，List l被迭代了好多次留荔，map，filter澜倦，distinct都分別是一次循環(huán)聚蝶，效率會(huì)不好杰妓。實(shí)際并非如此。這些返回另一個(gè)Stream的方法都是“懶（lazy）”的碘勉，而最后返回最終結(jié)果的collect方法則是“急（eager）”的巷挥。在遇到eager方法之前，lazy的方法不會(huì)執(zhí)行恰聘。
當(dāng)遇到eager方法時(shí)句各，前面的lazy方法才會(huì)被依次執(zhí)行吸占。而且是管道貫通式執(zhí)行晴叨。這意味著每一個(gè)元素依次通過這些管道。例如有個(gè)元素“3”矾屯，首先它被map成整數(shù)型3兼蕊；然后通過filter，發(fā)現(xiàn)是素?cái)?shù)件蚕，被保留下來孙技；又通過distinct，如果已經(jīng)有一個(gè)3了排作，那么就直接丟棄牵啦，如果還沒有則保留。這樣妄痪，3個(gè)操作其實(shí)只經(jīng)過了一次循環(huán)哈雏。
除collect外其它的eager操作還有forEach，toArray衫生，reduce等裳瘪。
下面來看一下也許是最常用的收集器方法，groupingBy：
//給出一個(gè)String類型的數(shù)組罪针，找出其中各個(gè)素?cái)?shù)彭羹，并統(tǒng)計(jì)其出現(xiàn)次數(shù)
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))
它的意思是：把結(jié)果收集到一個(gè)Map中，用統(tǒng)計(jì)到的各個(gè)素?cái)?shù)自身作為鍵泪酱，其出現(xiàn)次數(shù)作為值派殷。
下面是一個(gè)reduce的例子：
//給出一個(gè)String類型的數(shù)組，求其中所有不重復(fù)素?cái)?shù)的和
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方法用來產(chǎn)生單一的一個(gè)最終結(jié)果墓阀。
流有很多預(yù)定義的reduce操作愈腾，如sum()，max()岂津，min()等虱黄。
再舉個(gè)現(xiàn)實(shí)世界里的栗子比如：
// 統(tǒng)計(jì)年齡在25-35歲的男女人數(shù)、比例
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 λ表達(dá)式的更多用法
// 嵌套的λ表達(dá)式
Callable c1 = () -> () -> { System.out.println("Nested lambda"); };
c1.call().run();
// 用在條件表達(dá)式中
Callable c2 = true ? (() -> 42) : (() -> 24);
System.out.println(c2.call());
// 定義一個(gè)遞歸函數(shù)吮成，注意須用this限定
protected UnaryOperator factorial = i -> i == 0 ? 1 : i * this.factorial.apply( i - 1 );
...
System.out.println(factorial.apply(3));
在Java中橱乱，隨聲明隨調(diào)用的方式是不行的辜梳，比如下面這樣，聲明了一個(gè)λ表達(dá)式(x, y) -> x + y泳叠，同時(shí)企圖通過傳入實(shí)參(2, 3)來調(diào)用它：
int five = ( (x, y) -> x + y ) (2, 3); // ERROR! try to call a lambda in-place
這在C++中是可以的作瞄，但Java中不行。Java的λ表達(dá)式只能用作賦值危纫、傳參宗挥、返回值等。
4. 其它相關(guān)概念
4.1 捕獲（Capture）
捕獲的概念在于解決在λ表達(dá)式中我們可以使用哪些外部變量（即除了它自己的參數(shù)和內(nèi)部定義的本地變量）的問題种蝶。
答案是：與內(nèi)部類非常相似契耿，但有不同點(diǎn)。不同點(diǎn)在于內(nèi)部類總是持有一個(gè)其外部類對(duì)象的引用螃征。而λ表達(dá)式呢搪桂，除非在它內(nèi)部用到了其外部類（包圍類）對(duì)象的方法或者成員，否則它就不持有這個(gè)對(duì)象的引用盯滚。
在Java8以前踢械，如果要在內(nèi)部類訪問外部對(duì)象的一個(gè)本地變量，那么這個(gè)變量必須聲明為final才行魄藕。在Java8中内列，這種限制被去掉了，代之以一個(gè)新的概念背率，“effectively final”话瞧。它的意思是你可以聲明為final，也可以不聲明final但是按照final來用退渗，也就是一次賦值永不改變移稳。換句話說，保證它加上final前綴后不會(huì)出編譯錯(cuò)誤会油。
在Java8中个粱，內(nèi)部類和λ表達(dá)式都可以訪問effectively final的本地變量。λ表達(dá)式的例子如下：
...
int tmp1 = 1; //包圍類的成員變量
static int tmp2 = 2; //包圍類的靜態(tài)成員變量
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; // 編譯錯(cuò)都许！對(duì)tmp5賦值導(dǎo)致它不是effectively final的
return tmp5;
};
...
tmp5 = 9; // 編譯錯(cuò)！對(duì)tmp5賦值導(dǎo)致它不是effectively final的
}
...
Java要求本地變量final或者effectively final的原因是多線程并發(fā)問題嫂冻。內(nèi)部類胶征、λ表達(dá)式都有可能在不同的線程中執(zhí)行，允許多個(gè)線程同時(shí)修改一個(gè)本地變量不符合Java的設(shè)計(jì)理念桨仿。
4.2 方法引用（Method reference）
任何一個(gè)λ表達(dá)式都可以代表某個(gè)函數(shù)接口的唯一方法的匿名描述符睛低。我們也可以使用某個(gè)類的某個(gè)具體方法來代表這個(gè)描述符，叫做方法引用。例如：
Integer::parseInt //靜態(tài)方法引用
System.out::print //實(shí)例方法引用
Person::new?????? //構(gòu)造器引用
下面是一組例子钱雷，教你使用方法引用代替λ表達(dá)式：
//c1 與 c2 是一樣的（靜態(tài)方法引用）
Comparator c2 = (x, y) -> Integer.compare(x, y);
Comparator c1 = Integer::compare;
//下面兩句是一樣的（實(shí)例方法引用1）
persons.forEach(e -> System.out.println(e));
persons.forEach(System.out::println);
//下面兩句是一樣的（實(shí)例方法引用2）
persons.forEach(person -> person.eat());
persons.forEach(Person::eat);
//下面兩句是一樣的（構(gòu)造器引用）
strList.stream().map(s -> new Integer(s));
strList.stream().map(Integer::new);
使用方法引用骂铁，你的程序會(huì)變得更短些。現(xiàn)在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 //引用某個(gè)對(duì)象的父類方法
String[]::new //引用一個(gè)數(shù)組的構(gòu)造器
4.3 默認(rèn)方法（Default method）
Java8中罩抗，接口聲明里可以有方法實(shí)現(xiàn)了拉庵，叫做默認(rèn)方法。在此之前套蒂，接口里的方法全部是抽象方法钞支。
public interface MyInterf {
String m1();
default String m2() {
return "Hello default method!";
}
}
這實(shí)際上混淆了接口和抽象類，但一個(gè)類仍然可以實(shí)現(xiàn)多個(gè)接口操刀，而只能繼承一個(gè)抽象類烁挟。
這么做的原因是：由于Collection庫(kù)需要為批處理操作添加新的方法，如forEach()馍刮，stream()等信夫，但是不能修改現(xiàn)有的Collection接口——如果那樣做的話所有的實(shí)現(xiàn)類都要進(jìn)行修改窃蹋，包括很多客戶自制的實(shí)現(xiàn)類卡啰。所以只好使用這種妥協(xié)的辦法。
如此一來警没，我們就面臨一種類似多繼承的問題匈辱。如果類Sub繼承了兩個(gè)接口，Base1和Base2杀迹，而這兩個(gè)接口恰好具有完全相同的兩個(gè)默認(rèn)方法亡脸，那么就會(huì)產(chǎn)生沖突。這時(shí)Sub類就必須通過重載來顯式指明自己要使用哪一個(gè)接口的實(shí)現(xiàn)（或者提供自己的實(shí)現(xiàn)）：
public class Sub implements Base1, Base2 {
public void hello() {
Base1.super.hello(); //使用Base1的實(shí)現(xiàn)
}
}
除了默認(rèn)方法树酪，Java8的接口也可以有靜態(tài)方法的實(shí)現(xiàn)：
public interface MyInterf {
String m1();
default String m2() {
return "Hello default method!";
}
static String m3() {
return "Hello static method in Interface!";
}
}
4.4 生成器函數(shù)（Generator function）
有時(shí)候一個(gè)流的數(shù)據(jù)源不一定是一個(gè)已存在的集合對(duì)象浅碾，也可能是個(gè)“生成器函數(shù)”。一個(gè)生成器函數(shù)會(huì)產(chǎn)生一系列元素续语，供給一個(gè)流垂谢。Stream.generate(Supplier s)就是一個(gè)生成器函數(shù)。其中參數(shù)Supplier是一個(gè)函數(shù)接口疮茄，里面有唯一的抽象方法 get()滥朱。
下面這個(gè)例子生成并打印5個(gè)隨機(jī)數(shù)：
Stream.generate(Math::random).limit(5).forEach(System.out::println);
注意這個(gè)limit(5)，如果沒有這個(gè)調(diào)用力试，那么這條語句會(huì)永遠(yuǎn)地執(zhí)行下去徙邻。也就是說這個(gè)生成器是無窮的。這種調(diào)用叫做終結(jié)操作畸裳，或者短路（short-circuiting）操作缰犁。
