在2013年將發布的JavaSE8 中將包含一個叫做Lambda Project 的計劃，在今年6月份的JSR-335 草案中有描述。
JSR-335 將閉包引入了Java 。閉包在現在的很多流行的語言中都存在，例如C++、C# 。閉包允許我們創建函數指針，並把它們作為參數傳遞。在這篇文章中，我們將粗略的看一遍Java8的特性，並介紹Lambda表達式。而且我將試著放一些樣例程序來解釋一些概念和語法。
Java 編程語言給我們提供了接口的概念，接口裡可以定義抽象的方法。接口定義了API，並希望用戶或者供應商來實現這些方法。很多時候，我們並不為一些接口創建獨立的實現類，我們通過寫一個匿名內部類來寫一個內聯的接口實現。
匿名類使用的非常廣泛。匿名內部類使用的最常見的場景就是事件處理器了。其次匿名內部類還常被用在多線程的程序中，我們通常寫匿名內部類,而不是創建Runnable/Callable 接口的實現類。
就像我們討論的一樣，一個匿名類就是一個內聯的給定的接口的實現。通常我們將這個實現類的對像作為參數傳遞給一個方法，然後這個方法將在內部調用傳遞過來的實現類的方法。故這種接口叫做回調接口，這些方法叫做回調方法。
雖然匿名類到處都在使用，但是他們還是有很多問題。第一個主要問題是複雜。這些類讓代碼的層級看起來很亂很複雜，也稱作Vertical Problem 。第二，他們不能訪問封裝類的非final 成員。 this 這個關鍵字將變得很有迷惑性。如果一個匿名類有一個與其封裝類相同的成員名稱，內部變量將會覆蓋外部的成員變量，在這種情況下，外部的成員在匿名類內部將是不可見的，甚至不能通過this 關鍵字來訪問。因為this 關鍵字值得是匿名類對象本身而不是他的封裝類的對象。
public void anonymousExample() { String nonFinalVariable = "Non Final Example"; String variable = "Outer Method Variable"; new Thread(new Runnable() { String variable = "Runnable Class Member"; public void run() { String variable = "Run Method Variable"; //Below line gives compilation error. //System.out.println("->" + nonFinalVariable); System.out.println("->" + variable); System.out.println( "->" + this.variable); } }).start();}輸出是:
->Run Method Variable->Runnable Class Member
這個例子很好的說明了我上面所說的這個問題，而Lambda 表達式幾乎解決了匿名內部類帶來的所有問題。在我們進一步探討lambda 表達式之前，讓我們來看一看Functional Interfaces。
Functional Interfaces
Functional Interfaces 是一個只有單個方法的接口，這代表了這個方法契約。
上面的定義中的只有一個實際上並沒有那麼簡單。這段有些不懂，請讀者查看原文（The 'Single' method can exist in the form of multiple abstract methods that are inherited from superinterfaces. But in that case the inherited methods should logically represent a single method or it might redundantly declare a method that is provided by classes like Object, eg toString.）
下面的例子清楚的展示了怎樣理解Functional Interfaces 的概念。
interface Runnable { void run(); }// Functionalinterface Foo { boolean equals(Object obj); }// Not functional; equals is already an implicit memberinterface Bar extends Foo {int compare(String o1, String o2); }// Functional; Bar has one abstract non-Object methodinterface Comparator { boolean equals(Object obj); int compare(T o1, T o2);}// Functional; Comparator has one abstract non-Object methodinterface Foo {int m(); Object clone(); }// Not functional; method Object.clone is not publicinterface X { int m(Iterable arg); }interface Y { int m(Iterable arg); }interface Z extends X, Y {}// Functional: two methods, but they have the same signature大多數回調接口都是Functional Interfaces。例如Runnable,Callable,Comparator 等等。以前被稱作SAM（Single Abstract Method）
Lambda 表達式
我們上邊說過，匿名類的一個主要問題是是代碼的層級看起來很亂，也就是Vertical Problem 了，Lamdba 表達式實際上就是匿名類，只不過他們的結構更輕量，更短。 Lambda 表達式看起來像方法。他們有一個正式的參數列表和這些參數的塊體表達。
(String s)-> s.lengh;() -> 43;(int x, int y) -> x + y;
上面的例子的意思是，第一個表達式接收一個String 變量作為參數，然後返回字符串的長度。第二個不帶任何參數，並返回43。最後，第三個接受兩個整數x 和y ，並返回其和。
在看了許多文字後，終於，我可以給出第一個Lambda 表達式的例子了，這個例子運行在JavaSE8 的預覽版下：
public class FirstLambdaExpression { public String variable = "Class Level Variable"; public static void main(String[] arg) { new FirstLambdaExpression().lambdaExpression(); } public void lambdaExpression(){ String variable = "Method Local Variable"; String nonFinalVariable = "This is non final variable"; new Thread (() -> { //Below line gives compilation error //String variable = "Run Method Variable" System.out.println("->" + variable); System.out.println("->" + this.variable); }).start(); }}輸出是：
->Method Local Variable->Class Level Variable
你可以比較一些使用Lambda 表達式和使用匿名內部類的區別。我們可以清楚的說，使用Lambda 表達式的方式寫匿名類解決了變量可見性的問題。你可以看一下代碼中的註釋， Lambda 表達式不允許創建覆蓋變量。
通常的Lambda 表達式的語法包括一個參數列表，箭頭關鍵字"->"最後是主體。主體可以是表達式（單行語句）也可以是多行語句塊。如果是表達式，將被計算後返回，如果是多行的語句塊，就看起來跟方法的語句塊很相似了，可以使用return 來指定返回值。 break 和continue 只能用在循環內部。
為什麼選擇這個特殊的語法形式呢，因為目前C# 和Scala 中通常都是這種樣式，也算是Lambda 表達式的通用寫法。這樣的語法設計基本上解決了匿名類的複雜性。但是與此同時他也是非常靈活的，例如，如果方法體是單個表達式，大括號和return 語句都是不需要的。表達式的結果就是作為他自己的返回值。這種靈活性可以保持代碼簡潔。
Lambda 表達式用作匿名類,因此他們可以靈活運用在其他模塊或在其他Lambda 表達式(嵌套的Lambda 表達式)。
//Lambda expression is enclosed within methods parameter block.//Target interface type is the methods parameter type.String user = doSomething(() -> list.getProperty(“propName”);//Lambda expression is enclosed within a thread constructor //target interface type is contructors paramter ie Runnablenew Thread (() -> { System.out.println("Running in different thread");}).start();
如果你仔細看看lambda 表達式,您將看到,目標接口類型不是一個表達式的一部分。編譯器會幫助推斷lambda 表達式的類型與周圍環境。
Lambda 表達式必須有一個目標類型，而他們可以適配任意可能的目標類型。當目標類型是一個接口的時候，下面的條件必須滿足，才能編譯正確：
由於編譯器可以通過目標類型的聲明中得知參數類型和個數，所以在Lambda 表達式中，可以省略參數類型聲明。
Comparator c = (s1, s2) -> s1.compareToIgnoreCase(s2);
而且，如果目標類型中聲明的方法只接收一個參數（很多時候都是這樣的），那麼參數的小括號也是可以不寫的，例如：
ActionListenr listenr = event -> event.getWhen();
一個很明顯的問題來了，為什麼Lambda 表達式不需要一個指定的方法名呢？
答案是：Lambda 表達式只能用於functional interface ，而functional interface 只有一個方法。
當我們確定一個functional interface 來創建Lambda 表達式的時候，編譯器可以感知functional interface 中方法的簽名，並且檢查給定的表達式是否匹配。
這種靈活的語法幫助我們避免了使用匿名類的Vertical Problem ，而且不會帶來Horizontal Problem（單行語句非常長）。
Lambda 表達式的語法是上下文相關的,但是這些並不是第一次出現。 Java SE 7添加的diamond operators 也有這個概念,通過上下文推斷類型。
void invoke(Runnable r) {r.run()}void Future invoke(Callable r) {return c.compute()}//above are two methods, both takes parameter of type functional interfaceFuture s = invoke(() -> "Done"); //Which invoke will be called?
上面問題的答案是調用接收Callable參數的方法。在這種情況下編譯器會通過不同參數類型的重載解決。當有不止一個適用的重載方法,編譯器也檢查lambda表達式與相應的目標類型的兼容性。簡單的說，上面的invoke方法期望一個返回，但是只有一個invoke方法具有返回值。
Lambda表達式可以顯式的轉換為指定的目標類型，只要跟對應的類型兼容。看一下下面的程序，我實現了三種Callable，而且都將其轉換為Callable類型。
public class FirstSightWithLambdaExpressions { public static void main(String[] args) { List list = Arrays.asList( (Callable)()->"callable 1", (Callable) ()->"callable 2", (Callable) ( )->"callable 3"); ExecutorService e = Executors.newFixedThreadPool(2); List futures = null; try { futures = e.invokeAll(list); new FirstSightWithLambdaExpressions().dumpList(futures); } catch (InterruptedException | ExecutionException e1) { e1.printStackTrace(); } e.shutdown(); } public void dumpList(List list) throws InterruptedException, ExecutionException { for (Future future : list) { System.out.println(future.get()) ; } }}正如我們前面討論的一樣，匿名類不能訪問周圍環境中非final的變量。但是Lambda表達式裡就沒有這個限制。
目前,該定義的functional interfaces 只適用於接口。我試著對一個只有一個抽象方法的抽像類創建一個lambda 表達式,但出了一個編譯錯誤。按照jsr - 335,未來版本的lambda 表達式可能支持Functional Classes。
方法引用
方法引用被用作引用一個方法而不調用它。
Lambda 表達式允許我們定義一個匿名的方法，並將它作為Functional interface 的一個實例。方法引用跟Lambda 表達式很像，他們都需要一個目標類型，但是不同的是方法引用不提供方法的實現，他們引用一個已經存在的類或者對象的方法。
System::getProperty"abc"::lengthString::lengthsuper::toStringArrayList::new
上面的語句展示了方法和構造函數的引用的通用語法。這裡我們看到引入了一個新的操作符“::'(雙冒號)。我尚不清楚確切名稱為這個操作符,但是JSR 指它作為分隔符，維基百科頁面是指它作為一個範圍解析操作符。作為我們的參考,本教程的範圍內,我們將簡單地將它作為分隔符。
目標引用或者說接收者被放在提供者和分隔符的後面。這形成了一個表達式,它能夠引用一個方法。在最後聲明上述代碼,該方法的名字是“new”。這個表達式引用的是ArrayList 類的構造方法（下一節再討論構造方法的引用）
再進一步了解這個之前，我想讓你看一看方法引用的強大之處，我創建了一個簡單的Employee 數組的排序程序。
import java.util.Arrays;import java.util.List;import java.util.concurrent.ExecutionException;import java.util.concurrent.Future;public class MethodReference { public static void main (String[] ar){ Employee[] employees = {new Employee("Nick"), new Employee("Robin"), new Employee("Josh"), new Employee("Andy"), new Employee("Mark")}; System.out.println( "Before Sort:"); dumpEmployee(employees); Arrays.sort(employees, Employee::myCompare); System.out.println("After Sort:"); dumpEmployee(employees); } public static void dumpEmployee(Employee[ ] employees){ for(Employee emp : Arrays.asList(employees)){ System.out.print(emp.name+", "); } System.out.println(); }}class Employee { String name; Employee( String name) { this.name = name; } public static int myCompare(Employee emp1, Employee emp2) { return emp1.name.compareTo(emp2.name); }}輸出是：
Before Sort: Nick, Robin, Josh, Andy, Mark, After Sort: Andy, Josh, Mark, Nick, Robin,
輸出沒什麼特別，Employee 是一個非常簡單的類，只有一個name 屬性。靜態方法myCompare 接收兩個Employee 對象，返回他們名字的比較。
在main 方法中我創建了一個不同的employee 的數組，並且將它連同一個方法引用表達式（ Employee::myCompare ）傳遞給了Arrays.sort 方法。
等一下，如果我們看Javadoc 你會發現sort 方法的第二個參數是Comparator 類型的，但是我們卻傳遞了Employee 的一個靜態方法引用。重要的問題就在這了，我既沒有讓Employee 實現Comparable 接口，也沒有寫一個獨立的Comparator 類，但是輸出確實沒有任何問題。
讓我們來看一看這是為什麼。 Arrays.sort 方法期望一個Comparator 的實例，而這個Comparator 是一個functional interface ，這就意味著他只有一個方法，就是compare 了。這裡我們同樣惡意傳一個Lambda 表達式，在這個表達式中提供compare 方法的實現。但是在我們的里中，我們的Employee 類已經有了一個自己的比較方法。只是他們的名字是不一樣的，參數的類型、數量，返回值都是相同的，這裡我們就可以創建一個方法引用，並將它傳遞給sort 作為第二個參數。
當有多個相同的名稱的方法的時候，編譯器會根據目標類型選擇最佳的匹配。為了搞明白，來看一個例子：
public static int myCompare(Employee emp1, Employee emp2) { return emp1.name.compareTo(emp2.name);}//Another method with the same name as of the above.public static int myCompare(Integer int1, Integer int2) { return int1.compareTo(int2);}我創建了兩個不同的數組，用作排序。
Employee[] employees = {new Employee("Nick"), new Employee("Robin"), new Employee("Josh"), new Employee("Andy"), new Employee("Mark")};Integer[] ints = {1 , 4, 8, 2, 3, 8, 6};現在，我執行下面的兩行代碼
Arrays.sort(employees, Employee::myCompare);Arrays.sort(ints, Employee::myCompare);
這裡，兩行代碼中的方法引用聲明都是相同的（Employee::myCompare），唯一不同的是我們傳入的數組，我們不需要傳遞一個含糊不清的標記用以知名那個方法作為方法引用，編譯器會幫助我們檢查第一個參數，並且智能的找到合適的方法。
不要被靜態方法誤導了哦，我們還可以創建實例方法的引用。對於靜態方法我們使用類名::方法名來寫方法引用，如果是實例方法的引用，則是對象::方法名。
上面的例子已經是相當不錯的了，但是我們不必為整型的比較單獨寫一個方法，因為Integer已經實現了Comparable並且提供了實現方法compareTo。所以我們直接使用下面這一行就行了：
Arrays.sort(ints, Integer::compareTo);
看到這裡，你是否覺得有點迷惑？沒有？那我來讓你迷惑一下這裡， Integer 是一個類名（而不是一個像new Integer() 一樣的實例），而compareTo 方法卻是Integer 類的成員方法（非靜態）.如果你仔細看了我上面的描述就會知道，成員方法的方法引用::之前應該是對象，但是為什麼這裡的語句確實合法的。
答案是：這種類型的語句允許使用在一些特定的類型中。 Integer是一個數據類型，而對於數據類型來說，這種語句是允許的。
如果我們將Employee 的方法myCompare 變成非靜態的，然後這樣使用：Employee::myCompare，就會出編譯錯誤：No Suitable Method Found。
構造方法引用
構造方法引用被用作引用一個構造方法而不實例化指定的類。
構造方法引用是JavaSE 8 的一個新的特性。我們可以構造一個構造方法的引用，並且將它作為參數傳遞給目標類型。
當我們使用方法引用的時候，我們引用一個已有的方法使用他們。同樣的，在使用構造方法引用的時候，我們創建一個已有的構造方法的引用。
上一節中我們已經看到了構造方法引用的語法類名::new，這看起來很像方法引用。這種構造方法的引用可以分配給目標functional interfaces 的實例。一個類可能有多個構造方法，在這種情況下，編譯器會檢查functional interfaces 的類型，最終找到最好的匹配。
對我來說寫出第一個構造方法引用的程序有些困難，雖然我理解了他的語法，但是我卻不知道怎麼使用它，以及它有什麼用。最後，我花費了很久的努力，終於“啊，找到了...”，看看下面的程序吧。
public class ConstructorReference { public static void main(String[] ar){ MyInterface in = MyClass::new; System.out.println("->"+in.getMeMyObject()); }}interface MyInterface{ MyClass getMeMyObject() ;}class MyClass{ MyClass(){}}輸出是：
->com.MyClass@34e5307e
這看起來有點神奇是吧，這個接口和這個類除了接口中聲明的方法的返回值是MyClass 類型的，沒有任何關係。
這個例子又激起了我心中的另一個問題：怎樣實例化一個帶參數的構造方法引用？看看下面的程序：
public class ConstructorReference { public static void main(String[] ar){ EmlpoyeeProvider provider = Employee::new; Employee emp = provider.getMeEmployee("John", 30); System.out.println("->Employee Name: " +emp.name); System.out.println("->Employee Age: "+emp.age); }}interface EmlpoyeeProvider{ Employee getMeEmployee(String s, Integer i);}class Employee{ String name; Integer age; Employee (String name, Integer age){ this.name = name; this.age = age; }}輸出是：
->Employee Name: John->Employee Age: 30
在看完這篇文章之前，讓我們再來看一看JavaSE8中的最酷的一個特性--默認方法（Default Methods）
默認方法（Default Methods）
JavaSE8 中將會引入一個叫做默認方法的概念。早起的Java 版本的接口擁有非常嚴格的接口，接口包含了一些抽象方法的聲明，所有非抽象的實現類必須要提供所有這些抽象方法的實現，甚至是這些方法沒有用或者不合適出現在一些特殊的實現類中。在即將到來的Java 版本中，允許我們在接口中定義方法的默認實現。廢話不多說，看下面：
public class DefaultMethods { public static void main(String[] ar){ NormalInterface instance = new NormalInterfaceImpl(); instance.myNormalMethod(); instance.myDefaultMethod(); }}interface NormalInterface{ void myNormalMethod(); void myDefaultMethod () default { System.out.println("-> myDefaultMethod"); }}class NormalInterfaceImpl implements NormalInterface{ @Override public void myNormalMethod() { System.out.println("-> myNormalMethod"); }}輸出是：
-> myDefaultMethod
上面的接口中聲明了兩個方法，但是這個接口的實現類只實現了其中一個，因為myDefaultMethod 使用default 修飾符標記了，而且提供了一個方法塊用作默認實現。通用的重載規則在這裡仍然生效。如果實現類實現了接口中的方法，調用的時候將是調用類中的方法，否則，默認實現將被調用。
集成父接口的接口可以增加、改變、移除父接口中的默認實現。
interface ParentInterface{ void initiallyNormal(); void initiallyDefault () default{ System.out.println("-> myDefaultMethod"); }}interface ChildInterface extends ParentInterface{ void initiallyNormal() default{ System.out.println("now default - > initiallyNormal"); } void initiallyDefault (); //Now a normal method}在這個例子中，ParentInterface 定義了兩個方法，一個是正常的，一個是有默認實現的，子接口只是簡單的反了過來，給第一個方法添加了默認實現，給第二個方法移除了默認實現。
設想一個類繼承了類C ，實現了接口I ，而且C 有一個方法，而且跟I中的一個提供默認方法的方法是重載兼容的。在這種情況下，C中的方法會優先於I中的默認方法，甚至C中的方法是抽象的時候，仍然是優先的。
public class DefaultMethods { public static void main(String[] ar){ Interfaxe impl = new NormalInterfaceImpl(); impl.defaultMethod(); }}class ParentClass{ public void defaultMethod() { System.out.println("->ParentClass "); }}interface Interfaxe{ public void defaultMethod() default{ System.out.println("->Interfaxe"); }}class NormalInterfaceImpl extends ParentClass implements Interfaxe{}輸出是：
->ParentClass
第二個例子是，我的類實現了兩個不同的接口，但是兩個接口中都提供了相同的具有默認實現的方法的聲明。在這種情況下，編譯器將會搞不清楚怎麼回事，實現類必須選擇兩個的其中一個實現。這可以通過如下的方式來使用super 來搞定。
public class DefaultMethods { public static void main(String[] ar){ FirstInterface impl = new NormalInterfaceImpl(); impl.defaultMethod(); }}interface FirstInterface{ public void defaultMethod() default{ System.out.println("-> FirstInterface"); }}interface SecondInterface{ public void defaultMethod() default{ System.out.println("->SecondInterface"); }}class NormalInterfaceImpl implements FirstInterface, SecondInterface{ public void defaultMethod(){ SecondInterface.super.defaultMethod( ); }}輸出是：
->SecondInterface
現在，我們已經看完了Java 閉包的介紹。這個文章中，我們接觸到了Functional Interfaces 和Java Closure ，理解了Java 的Lambda 表達式，方法引用和構造方法引用。而且我們也寫出了Lambda 表達式的Hello World 例子。
JavaSE8 很快就要到來了，我將很高興的擁抱這些新特性，也許這些新特性還是有些迷惑不清，但是我相信，隨著時間的推移，會變得越來越好。