接上一篇：初探Lambda表達式/Java多核編程【2】并行與組合行為
本節是第二章開篇，前一章已經淺顯地將所有新概念點到，書中剩下的部分將對這些概念做一個基礎知識的補充與深入探討實踐。
本章將介紹Lambda表達式基礎知識。
前言
把上一張書中的結語放到這里作為本章學習內容的開頭，以此來概括Lambda表達式的優點：
- 提升性能、自動的并行化
-
更棒的API（
comparing(...)細粒度的方法將成為標準） - 編碼風格得到改進、代碼簡化
反觀前面幾篇文章中的代碼實踐，以上三個優點全部得到了驗證。
Lambda語法
前文中我們已經提到，Java中無法聲明獨立的純函數，但是Lambda的出現提供了一種與獨立函數更為近似的實現方式。就只看Lambda形式，的確與很多精簡語法的腳本語言中所聲明的函數高度相似：
|
1
2
3
|
# CoffeeScripteat = (x) -> alert("#{x} has been eatten!") |
總之光看上去就像那么回事：）
那么Lambda表達式的語法又是怎樣的呢？
- 參數列表
- Lambda體
兩部分之間使用->分割，看幾個例子：
|
1
2
3
4
5
6
7
8
9
|
p -> p.translate();i -> new Point();(a, b) -> return a + b;() -> "Ha!";(x, y, z) -> { x += y; y += z; z += x;} |
箭頭左邊接收任意數量的參數，右邊則為表達式體，描述所需的行為。
顯而易見，在一般情況下無需顯式地指定參數類型，除非上下文的信息無法是編譯器推斷出相應的類型：
|
1
|
(int x, int y) -> x + y; |
參數可以聲明為final，也可以添加注解（@Nullable, etc.）。
表達式體部分可以為方法的調用，如str.length()等等，也可以是表達式，如加減乘除等等，即“語句Lambda”與“表達式Lambda”這兩種形式。
另外關于返回值，有則用return sth_to_return;，沒有則用return;或直接不寫返回語句。
最后，需要注意的是Lambda表達式不需要也不允許使用throws關鍵字來聲明可能產生并需要向上拋出的異常。
Lambda與匿名內部類
前幾篇文章中常常將Lambda與匿名內部類做粗淺的類比與對比，現在我們將就這一點做具體深入的分析。
語法
首先在語法層面，Lambda表達式有時候被稱為匿名內部類的“語法糖”，這表明了二者之間存在語法繁簡的明顯區別。
無標識性問題
其次便是標識性問題，我們知道Java中為了區分對象，每一個對象（即使是匿名內部類的實例）都具有唯一標識，而依賴于對象而存在的行為（即我們所說的方法）也會與此標識相關聯。
例如：
|
1
2
3
4
|
String bar = "bar";String foo = "foo";System.out.println(bar.hashCode()); // => 97299System.out.println(foo.hashCode()); // => 101574 |
但是對于Lambda表達式而言，情況便不是如此的明朗，根據具體情況的不同，Lambda自身可能擁有標識也可能沒有。
況且，Lambda為的就是表示一種行為，趨向于純函數，因此一般情況下是不需要使用標識加以區分的。
作用域規則
再者就是兩者的作用域大小的區別。
對于匿名內部類而言，顯而易見，在類內可以沿用父類型（即函數接口）的名字。
而對于Lambda，則不能。
我們用Runnable接口來舉一個例子：
|
1
2
3
4
5
6
7
8
9
10
|
public interface LetsRun extends Runnable { String aString = "Big brother is watching.";}new Thread( new LetsRun() { @Override public void run() { System.out.println(aString); }}).run(); |
顯然，匿名內部類能夠直接沿用我們在LetsRun這個函數式接口中聲明的aString。
寫完這段代碼的同時，IDE給了我一個可以將匿名內部類折疊為Lambda的提示，現在就讓它幫我們自動折疊一下：
|
1
|
new Thread((LetsRun) () -> System.out.println(LetsRun.aString)).run(); |
注意此時需要打印的內容也同時自動變成了LetsRun.aString，印證了上述特征，即Lambda不能直接訪問父類型中的名字。
關于對外部變量的訪問（后面書中將此稱為“變量捕獲”），不論是匿名內部類還是Lambda，對于域外部變量的權限都是有限的。
在匿名內部類中，可以讀取外部量，但是不允許有修改變量的傾向。
也就是說，沒有嚴格的限制規定被訪問的外部量必須被聲明為final：
|
1
2
3
4
5
6
7
8
9
10
|
// This is OKString anotherString = "WAR IS PEACE / FREEDOM IS SLAVERY / IGNORANCE IS STRENGTH";// Also OKfinal String finalString = "Nineteen Eighty-Four";new Thread(new LetsRun() { @Override public void run() { System.out.println(aString + "\n" + anotherString + "\n" + finalString); }}).run(); |
倘若一旦在方法內修改了anotherString的值，編譯就無法通過。
同樣，折疊為Lambda后，依然是合法的：
|
1
2
|
new Thread((LetsRun) () -> System.out.println(LetsRun.aString + "\n" + anotherString + "\n" + finalString)).run(); |
關于變量捕獲的問題是下一小節的重點內容，在此暫時不做深究。
Lambda表達式在定義時，參數部分與表達式體內的命名可以暫時屏蔽掉字段的名稱：
|
1
2
3
4
5
|
public class Foo { String x, y; BinaryOperator binaryOperator = (x, y) -> x.hashCode() + y.hashCode(); // ...} |
另外，Lambda相當于語句塊，因此表達式體內持有和外部相同的語境，即this與super擁有相同含義：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class MySuperClass { public static final String aString = "Father";}public class MyClass extends MySuperClass { public static final String aString = "Son"; public void aMethod() { new Thread((LetsRun) () -> { System.out.println("--- Lambda ---"); System.out.println(super.aString); System.out.println(this.aString); }).run(); System.out.println("--- Outside ---"); System.out.println(super.aString); System.out.println(this.aString); }} |
運行結果：
|
1
2
3
4
5
6
|
--- Lambda ---FatherSon--- Outside ---FatherSon |
Lambda無法引用自身，因此可以用一種尷尬的方式遞歸調用自己：
|
1
|
intUnaryOperator = i -> i == 0 ? 1 : i * intUnaryOperator.applyAsInt(i - 1); |
小結
Lambda不從父類型中繼承任何名字，包括：
接口的靜態final字段
接口的靜態嵌套類
默認方法（將在后續介紹）
將全部被排除在作用域之外。
Lambda參數與表達式體中的局部聲明可以屏蔽字段名。
Lambda中的this和super的含義完全同外部一致。
而若在匿名內部類訪問外部對象的當前實例須用OuterClass.this，非常笨拙：
|
1
2
3
|
new Thread((LetsRun) () -> System.out.println(Foo.this.getClass().toString())).run(); |
遞歸Lambda時須注意Lambda變量無法被初始化，只能直接調用相應函數式接口中的方法。
本章代碼：
Foo.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import java.util.function.BinaryOperator;public class Foo { String x, y; BinaryOperator binaryOperator = (x, y) -> x.hashCode() + y.hashCode(); public static void main(String[] args) { String bar = "bar"; String foo = "foo"; System.out.println(bar.hashCode()); System.out.println(foo.hashCode()); new Thread((LetsRun) () -> System.out.println(LetsRun.aString)).run(); String anotherString = "WAR IS PEACE / FREEDOM IS SLAVERY / IGNORANCE IS STRENGTH"; final String finalString = "Nineteen Eighty-Four"; new Thread((LetsRun) () -> System.out.println(LetsRun.aString + "\n" + anotherString + "\n" + finalString)).run(); new MyClass().aMethod(); new Foo().accessOuterClassInAnnoymousInnerClass(); } public void accessOuterClassInAnnoymousInnerClass() { new Thread((LetsRun) () -> System.out.println(Foo.this.getClass().toString()) ).run(); }} |
LetsRun.java
|
1
2
3
|
public interface LetsRun extends Runnable { String aString = "Big brother is watching.";} |
MyClass.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import java.util.function.IntUnaryOperator;public class MyClass extends MySuperClass { public static final String aString = "Son"; IntUnaryOperator intUnaryOperator = null; public void aMethod() { new Thread((LetsRun) () -> { System.out.println("--- Lambda ---"); System.out.println(super.aString); System.out.println(this.aString); }).run(); System.out.println("--- Outside ---"); System.out.println(super.aString); System.out.println(this.aString); } public void factorial() { intUnaryOperator = i -> i == 0 ? 1 : i * intUnaryOperator.applyAsInt(i - 1); }} |
MySuperClass.java
|
1
2
3
|
public class MySuperClass { public static final String aString = "Father";} |
以及運行結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
97299101574Big brother is watching.Big brother is watching.WAR IS PEACE / FREEDOM IS SLAVERY / IGNORANCE IS STRENGTHNineteen Eighty-Four--- Lambda ---FatherSon--- Outside ---FatherSonclass Foo |
以上所述是小編給大家介紹的Java中Lambda表達式之Lambda語法與作用域解析，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
原文鏈接：http://www.cnblogs.com/hwding/p/6432084.html
