1. 什么是λ表達式
λ表達式本質上是一個匿名方法。讓我們來看下面這個例子：
|
1
2
3
|
public int add(int x, int y) { return x + y;} |
轉成λ表達式后是這個樣子：
|
1
|
(int x, int y) -> x + y; |
參數類型也可以省略，Java編譯器會根據上下文推斷出來：
|
1
|
(x, y) -> x + y; //返回兩數之和 |
或者
|
1
|
(x, y) -> { return x + y; } //顯式指明返回值 |
可見λ表達式有三部分組成：參數列表，箭頭（->），以及一個表達式或語句塊。
下面這個例子里的λ表達式沒有參數，也沒有返回值（相當于一個方法接受0個參數，返回void，其實就是Runnable里run方法的一個實現）：
|
1
|
|
如果只有一個參數且可以被Java推斷出類型，那么參數列表的括號也可以省略：
|
1
|
c -> { return c.size(); } |
2. λ表達式的類型（它是Object嗎？）
λ表達式可以被當做是一個Object（注意措辭）。λ表達式的類型，叫做“目標類型（target type）”。λ表達式的目標類型是“函數接口（functional interface）”，這是Java8新引入的概念。它的定義是：一個接口，如果只有一個顯式聲明的抽象方法，那么它就是一個函數接口。一般用@FunctionalInterface標注出來（也可以不標）。舉例如下：
|
1
2
3
4
5
|
@FunctionalInterfacepublic interface Runnable { void run(); }public interface Callable<V> { V call() throws Exception; }public interface ActionListener { void actionPerformed(ActionEvent e); }public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); } |
注意最后這個Comparator接口。它里面聲明了兩個方法，貌似不符合函數接口的定義，但它的確是函數接口。這是因為equals方法是Object的，所有的接口都會聲明Object的public方法——雖然大多是隱式的。所以，Comparator顯式的聲明了equals不影響它依然是個函數接口。
你可以用一個λ表達式為一個函數接口賦值：
|
1
|
Runnable r1 = () -> {System.out.println("Hello Lambda!");}; |
然后再賦值給一個Object：
|
1
|
Object obj = r1; |
但卻不能這樣干：
|
1
|
Object obj = () -> {System.out.println("Hello Lambda!");}; // ERROR! Object is not a functional interface! |
必須顯式的轉型成一個函數接口才可以：
|
1
|
Object o = (Runnable) () -> { System.out.println("hi"); }; // correct |
一個λ表達式只有在轉型成一個函數接口后才能被當做Object使用。所以下面這句也不能編譯：
|
1
|
System.out.println( () -> {} ); //錯誤! 目標類型不明 |
必須先轉型:
|
1
|
System.out.println( (Runnable)() -> {} ); // 正確 |
假設你自己寫了一個函數接口，長的跟Runnable一模一樣：
|
1
2
3
4
|
@FunctionalInterface public interface MyRunnable { public void run(); } |
那么
|
1
2
|
Runnable r1 = () -> {System.out.println("Hello Lambda!");}; MyRunnable2 r2 = () -> {System.out.println("Hello Lambda!");}; |
都是正確的寫法。這說明一個λ表達式可以有多個目標類型（函數接口），只要函數匹配成功即可。
但需注意一個λ表達式必須至少有一個目標類型。
JDK預定義了很多函數接口以避免用戶重復定義。最典型的是Function：
|
1
2
3
4
|
@FunctionalInterfacepublic interface Function<T, R> { R apply(T t);} |
這個接口代表一個函數，接受一個T類型的參數，并返回一個R類型的返回值。
另一個預定義函數接口叫做Consumer，跟Function的唯一不同是它沒有返回值。
|
1
2
3
4
|
@FunctionalInterfacepublic interface Consumer<T> { void accept(T t);} |
還有一個Predicate，用來判斷某項條件是否滿足。經常用來進行篩濾操作：
|
1
2
3
4
|
@FunctionalInterface public interface Predicate<T> { boolean test(T t); } |
綜上所述，一個λ表達式其實就是定義了一個匿名方法，只不過這個方法必須符合至少一個函數接口。
3. λ表達式的使用
3.1 λ表達式用在何處
λ表達式主要用于替換以前廣泛使用的內部匿名類，各種回調，比如事件響應器、傳入Thread類的Runnable等。看下面的例子：
|
1
2
3
4
5
6
7
8
9
|
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類庫來進行迭代，而不是客戶代碼。例如：
|
1
2
3
|
for(Object o: list) { // 外部迭代 System.out.println(o);} |
可以寫成：
|
1
|
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方法那樣，從而多個不同的操作可以在一個語句里串起來。看下面的例子：
|
1
2
3
4
|
List<Shape> 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的多核特性。
|
1
|
shapes.parallelStream(); // 或shapes.stream().parallel() |
來看更多的例子。下面是典型的大數據處理方法，Filter-Map-Reduce：
|
1
2
3
4
5
6
7
8
9
10
|
//給出一個String類型的數組，找出其中所有不重復的素數 public void distinctPrimary(String... numbers) { List<String> l = Arrays.asList(numbers); List<Integer> 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：
|
1
2
3
4
5
6
7
8
9
|
//給出一個String類型的數組，找出其中各個素數，并統計其出現次數public void primaryOccurrence(String... numbers) { List<String> l = Arrays.asList(numbers); Map<Integer, Integer> 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);} |
注意這一行：
|
1
|
Collectors.groupingBy(p->p, Collectors.summingInt(p->1)) |
它的意思是：把結果收集到一個Map中，用統計到的各個素數自身作為鍵，其出現次數作為值。
下面是一個reduce的例子：
|
1
2
3
4
5
6
7
8
9
10
|
//給出一個String類型的數組，求其中所有不重復素數的和public void distinctPrimarySum(String... numbers) { List<String> 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()等。
再舉個現實世界里的栗子比如：
|
1
2
3
4
5
6
7
8
9
|
// 統計年齡在25-35歲的男女人數、比例public void boysAndGirls(List<Person> persons) { Map<Integer, Integer> 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 λ表達式的更多用法
|
1
2
3
4
5
6
7
8
9
10
|
// 嵌套的λ表達式Callable<Runnable> c1 = () -> () -> { System.out.println("Nested lambda"); };c1.call().run();// 用在條件表達式中Callable<Integer> c2 = true ? (() -> 42) : (() -> 24);System.out.println(c2.call());// 定義一個遞歸函數，注意須用this限定protected UnaryOperator<Integer> factorial = i -> i == 0 ? 1 : i * this.factorial.apply( i - 1 );...System.out.println(factorial.apply(3)); |
在Java中，隨聲明隨調用的方式是不行的，比如下面這樣，聲明了一個λ表達式(x, y) -> x + y，同時企圖通過傳入實參(2, 3)來調用它：
|
1
|
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的本地變量。λ表達式的例子如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
... 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<Integer, Integer> f1 = i -> i + tmp1; Function<Integer, Integer> f2 = i -> i + tmp2; Function<Integer, Integer> f3 = i -> i + tmp3; Function<Integer, Integer> f4 = i -> i + tmp4; Function<Integer, Integer> f5 = i -> { tmp5 += i; // 編譯錯！對tmp5賦值導致它不是effectively final的 return tmp5; }; ... tmp5 = 9; // 編譯錯！對tmp5賦值導致它不是effectively final的}... |
Java要求本地變量final或者effectively final的原因是多線程并發問題。內部類、λ表達式都有可能在不同的線程中執行，允許多個線程同時修改一個本地變量不符合Java的設計理念。
4.2 方法引用（Method reference）
任何一個λ表達式都可以代表某個函數接口的唯一方法的匿名描述符。我們也可以使用某個類的某個具體方法來代表這個描述符，叫做方法引用。例如：
|
1
2
3
|
Integer::parseInt //靜態方法引用System.out::print //實例方法引用Person::new //構造器引用 |
下面是一組例子，教你使用方法引用代替λ表達式：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//c1 與 c2 是一樣的（靜態方法引用） Comparator<Integer> c2 = (x, y) -> Integer.compare(x, y); Comparator<Integer> 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方法可以改寫如下：
|
1
2
3
4
5
|
public void distinctPrimarySum(String... numbers) { List<String> l = Arrays.asList(numbers); int sum = l.stream().map(Integer::new).filter(Primes::isPrime).distinct().sum(); System.out.println("distinctPrimarySum result is: " + sum); } |
還有一些其它的方法引用:
|
1
2
|
super::toString //引用某個對象的父類方法String[]::new //引用一個數組的構造器 |
4.3 默認方法（Default method）
Java8中，接口聲明里可以有方法實現了，叫做默認方法。在此之前，接口里的方法全部是抽象方法。
|
1
2
3
4
5
6
|
public interface MyInterf { String m1(); default String m2() { return "Hello default method!"; }} |
這實際上混淆了接口和抽象類，但一個類仍然可以實現多個接口，而只能繼承一個抽象類。
這么做的原因是：由于Collection庫需要為批處理操作添加新的方法，如forEach()，stream()等，但是不能修改現有的Collection接口——如果那樣做的話所有的實現類都要進行修改，包括很多客戶自制的實現類。所以只好使用這種妥協的辦法。
如此一來，我們就面臨一種類似多繼承的問題。如果類Sub繼承了兩個接口，Base1和Base2，而這兩個接口恰好具有完全相同的兩個默認方法，那么就會產生沖突。這時Sub類就必須通過重載來顯式指明自己要使用哪一個接口的實現（或者提供自己的實現）：
|
1
2
3
4
5
|
public class Sub implements Base1, Base2 { public void hello() { Base1.super.hello(); //使用Base1的實現 } } |
除了默認方法，Java8的接口也可以有靜態方法的實現：
|
1
2
3
4
5
6
7
8
9
|
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<T> s)就是一個生成器函數。其中參數Supplier是一個函數接口，里面有唯一的抽象方法 <T> get()。
下面這個例子生成并打印5個隨機數：
|
1
|
Stream.generate(Math::random).limit(5).forEach(System.out::println); |
注意這個limit(5)，如果沒有這個調用，那么這條語句會永遠地執行下去。也就是說這個生成器是無窮的。這種調用叫做終結操作，或者短路（short-circuiting）操作。
參考資料：
http://openjdk.java.net/projects/lambda/
http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
以上所述是小編給大家介紹的Java8中的 Lambda表達式教程，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
