Java 8 lambda 表達式10個示例

時間 2019-11-17

原文原文鏈接

Java 8 發佈於4年前，日期是2014年3月18日，此次開創性的發佈在Java社區引起了很多討論，並讓你們感到激動。特性之一即是隨同發佈的lambda表達式，它將容許咱們將行爲傳到函數裏。在Java 8以前，若是想將行爲傳入函數，僅有的選擇就是匿名類，須要6行代碼。而定義行爲最重要的那行代碼，卻混在中間不夠突出。Lambda表達式取代了匿名類，取消了模板，容許用函數式風格編寫代碼。這樣有時可讀性更好，表達更清晰。html

在Java生態系統中，函數式表達與對面向對象的全面支持是個激動人心的進步。將進一步促進並行第三方庫的發展，充分利用多核CPU。java

儘管業界須要時間來消化Java 8，但我認爲任何嚴謹的Java開發者都不該忽視這次Java發佈的核心特性，即lambda表達式、函數式接口、流API、默認方法和新的Date以及Time API。express

做爲開發人員，我發現學習和掌握lambda表達式的最佳方法就是敢於嘗試，儘量多練習lambda表達式例子。鑑於受Java 8發佈的影響最大的是Java集合框架（Java Collections framework），因此最好練習流API和lambda表達式，用於對列表（Lists）和集合（Collections）數據進行提取、過濾和排序。編程

我一直在進行關於Java 8的寫做，過去也曾分享過一些資源來幫助你們掌握Java 8。本文分享在代碼中最有用的10個lambda表達式的使用方法，這些例子都短小精悍，將幫助你快速學會lambda表達式。api

Java 8 lambda表達式示例

我我的對Java 8發佈很是激動，尤爲是lambda表達式和流API。愈來愈多的瞭解它們，我能寫出更乾淨的代碼。雖然一開始並非這樣。第一次看到用lambda表達式寫出來的Java代碼時，我對這種神祕的語法感到很是失望，認爲它們把Java搞得不可讀，但我錯了。花了一天時間作了一些lambda表達式和流API示例的練習後，我開心的看到了更清晰的Java代碼。這有點像學習泛型，第一次見的時候我很討厭它。我甚至繼續使用老版Java 1.4來處理集合，直到有一天，朋友跟我介紹了使用泛型的好處（才意識到它的好處）。因此基本立場就是，不要畏懼lambda表達式以及方法引用的神祕語法，作幾回練習，從集合類中提取、過濾數據以後，你就會喜歡上它。下面讓咱們開啓學習Java 8 lambda表達式的學習之旅吧，首先從簡單例子開始。bash

例一、用lambda表達式實現Runnable

我開始使用Java 8時，首先作的就是使用lambda表達式替換匿名類，而實現Runnable接口是匿名類的最好示例。看一下Java 8以前的runnable實現方法，須要4行代碼，而使用lambda表達式只須要一行代碼。咱們在這裏作了什麼呢？那就是用() -> {}代碼塊替代了整個匿名類。閉包

// Java 8以前：
new Thread(new Runnable() {
    @Override
    public void run() {
    System.out.println("Before Java8, too much code for too little to do");
    }
}).start();

//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();
複製代碼

輸出：併發

too much code, for too little to do
Lambda expression rocks !! 
複製代碼

這個例子向咱們展現了Java 8 lambda表達式的語法。你可使用lambda寫出以下代碼：框架

(params) -> expression
(params) -> statement
(params) -> { statements } 
複製代碼

例如，若是你的方法不對參數進行修改、重寫，只是在控制檯打印點東西的話，那麼能夠這樣寫：jsp

() -> System.out.println("Hello Lambda Expressions");
複製代碼

若是你的方法接收兩個參數，那麼能夠寫成以下這樣：

(int even, int odd) -> even + odd 
複製代碼

順便提一句，一般都會把lambda表達式內部變量的名字起得短一些。這樣能使代碼更簡短，放在同一行。因此，在上述代碼中，變量名選用a、b或者x、y會比even、odd要好。

例二、使用Java 8 lambda表達式進行事件處理

若是你用過Swing API編程，你就會記得怎樣寫事件監聽代碼。這又是一箇舊版本簡單匿名類的經典用例，但如今能夠不這樣了。你能夠用lambda表達式寫出更好的事件監聽代碼，以下所示：

// Java 8以前：
JButton show =  new JButton("Show");
show.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
    System.out.println("Event handling without lambda expression is boring");
    }
}); 

// Java 8方式：
show.addActionListener((e) -> {
    System.out.println("Light, Camera, Action !! Lambda expressions Rocks");
});
複製代碼

Java開發者常用匿名類的另外一個地方是爲 Collections.sort() 定製 Comparator。在Java 8中，你能夠用更可讀的lambda表達式換掉醜陋的匿名類。我把這個留作練習，應該不難，能夠按照我在使用lambda表達式實現 Runnable 和 ActionListener 的過程當中的套路來作。

例三、使用lambda表達式對列表進行迭代

若是你使過幾年Java，你就知道針對集合類，最多見的操做就是進行迭代，並將業務邏輯應用於各個元素，例如處理訂單、交易和事件的列表。因爲Java是命令式語言，Java 8以前的全部循環代碼都是順序的，便可以對其元素進行並行化處理。若是你想作並行過濾，就須要本身寫代碼，這並非那麼容易。經過引入lambda表達式和默認方法，將作什麼和怎麼作的問題分開了，這意味着Java集合如今知道怎樣作迭代，並能夠在API層面對集合元素進行並行處理。下面的例子裏，我將介紹如何在使用 lambda或不使用lambda表達式的狀況下迭代列表。你能夠看到列表如今有了一個 forEach() 方法，它能夠迭代全部對象，並將你的lambda代碼應用在其中。

// Java 8以前：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
for (String feature : features) {
    System.out.println(feature);
} 

// Java 8以後：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
features.forEach(n -> System.out.println(n));

// 使用Java 8的方法引用更方便，方法引用由::雙冒號操做符標示，
// 看起來像C++的做用域解析運算符
features.forEach(System.out::println);
複製代碼

輸出：

Lambdas
Default Method
Stream API
Date and Time API 
複製代碼

列表循環的最後一個例子展現瞭如何在Java 8中使用方法引用（method reference）。你能夠看到C++裏面的雙冒號、範圍解析操做符如今在Java 8中用來表示方法引用。

例四、使用lambda表達式和函數式接口Predicate

除了在語言層面支持函數式編程風格，Java 8也添加了一個包，叫作 java.util.function。它包含了不少類，用來支持Java的函數式編程。其中一個即是Predicate，使用 java.util.function.Predicate 函數式接口以及lambda表達式，能夠向API方法添加邏輯，用更少的代碼支持更多的動態行爲。下面是Java 8 Predicate 的例子，展現了過濾集合數據的多種經常使用方法。Predicate接口很是適用於作過濾。

public static void main(String[] args) {
    List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");

    System.out.println("Languages which starts with J :");
    filter(languages, (str)->((String)str).startsWith("J"));

    System.out.println("Languages which ends with a ");
    filter(languages, (str)->((String)str).endsWith("a"));

    System.out.println("Print all languages :");
    filter(languages, (str)->true);

    System.out.println("Print no language : ");
    filter(languages, (str)->false);

    System.out.println("Print language whose length greater than 4:");
    filter(languages, (str)->((String)str).length() > 4);
}

public static void filter(List<String> names, Predicate condition) {
    for(String  name: names)  {
        if(condition.test(name)) {
            System.out.println(name + " ");
        }
    }
}
複製代碼

輸出：

Languages which starts with J :
Java
Languages which ends with a
Java
Scala
Print all languages :
Java
Scala
C++
Haskell
Lisp
Print no language :
Print language whose length greater than 4:
Scala
Haskell

// 更好的辦法
public static void filter(List names, Predicate condition) {
    names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {
        System.out.println(name + " ");
    });
}
複製代碼

能夠看到，Stream API的過濾方法也接受一個Predicate，這意味着能夠將咱們定製的 filter() 方法替換成寫在裏面的內聯代碼，這就是lambda表達式的魔力。另外，Predicate接口也容許進行多重條件的測試，下個例子將要講到。

例五、如何在lambda表達式中加入Predicate

上個例子說到，java.util.function.Predicate 容許將兩個或更多的 Predicate 合成一個。它提供相似於邏輯操做符AND和OR的方法，名字叫作 and()、or()，用於將傳入 filter() 方法的條件合併起來。例如，要獲得全部以J開始，長度爲四個字母的語言，能夠定義兩個獨立的 Predicate 示例分別表示每個條件，而後用 Predicate.and() 方法將它們合併起來，以下所示

// 甚至能夠用and()、or()邏輯函數來合併Predicate，
// 例如要找到全部以J開始，長度爲四個字母的名字，你能夠合併兩個Predicate並傳入
Predicate<String> startsWithJ = (n) -> n.startsWith("J");
Predicate<String> fourLetterLong = (n) -> n.length() == 4;
names.stream()
    .filter(startsWithJ.and(fourLetterLong))
    .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n)); 
複製代碼

相似地，也可使用 or() 方法。本例着重介紹了以下要點：可按須要將 Predicate 做爲單獨條件而後將其合併起來使用。簡而言之，你能夠以傳統Java命令方式使用 Predicate 接口，也能夠充分利用lambda表達式達到事半功倍的效果。

例六、Java 8中使用lambda表達式的Map和Reduce示例

本例介紹最廣爲人知的函數式編程概念map。它容許你將對象進行轉換。例如在本例中，咱們將 costBeforeTax 列表的每一個元素轉換成爲稅後的值。咱們將 x -> x*x lambda表達式傳到 map() 方法，後者將其應用到流中的每個元素。而後用 forEach() 將列表元素打印出來。使用流API的收集器類，能夠獲得全部含稅的開銷。有 toList() 這樣的方法將 map 或任何其餘操做的結果合併起來。因爲收集器在流上作終端操做，所以以後便不能重用流了。你甚至能夠用流API的 reduce() 方法將全部數字合成一個，下一個例子將會講到。

// 不使用lambda表達式爲每一個訂單加上12%的稅
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    System.out.println(price);
}

// 使用lambda表達式
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);
複製代碼

輸出：

112.0
224.0
336.0
448.0
560.0
112.0
224.0
336.0
448.0
560.0 
複製代碼

例6.二、Java 8中使用lambda表達式的Map和Reduce示例

在上個例子中，能夠看到map將集合類（例如列表）元素進行轉換的。還有一個 reduce() 函數能夠將全部值合併成一個。Map和Reduce操做是函數式編程的核心操做，由於其功能，reduce 又被稱爲摺疊操做。另外，reduce 並非一個新的操做，你有可能已經在使用它。SQL中相似 sum()、avg() 或者 count() 的彙集函數，實際上就是 reduce 操做，由於它們接收多個值並返回一個值。流API定義的 reduceh() 函數能夠接受lambda表達式，並對全部值進行合併。IntStream這樣的類有相似 average()、count()、sum() 的內建方法來作 reduce 操做，也有mapToLong()、mapToDouble() 方法來作轉換。這並不會限制你，你能夠用內建方法，也能夠本身定義。在這個Java 8的Map Reduce示例裏，咱們首先對全部價格應用 12% 的VAT，而後用 reduce() 方法計算總和。

// 爲每一個訂單加上12%的稅
// 老方法：
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double total = 0;
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    total = total + price;
}
System.out.println("Total : " + total);

// 新方法：
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();
System.out.println("Total : " + bill); 
複製代碼

輸出：

Total : 1680.0
Total : 1680.0
複製代碼

例七、經過過濾建立一個String列表

過濾是Java開發者在大規模集合上的一個經常使用操做，而如今使用lambda表達式和流API過濾大規模數據集合是驚人的簡單。流提供了一個 filter() 方法，接受一個 Predicate 對象，便可以傳入一個lambda表達式做爲過濾邏輯。下面的例子是用lambda表達式過濾Java集合，將幫助理解。

// 建立一個字符串列表，每一個字符串長度大於2
List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);
複製代碼

輸出：

Original List : [abc, , bcd, , defg, jk], filtered list : [abc, bcd, defg] 
複製代碼

另外，關於 filter() 方法有個常見誤解。在現實生活中，作過濾的時候，一般會丟棄部分，但使用filter()方法則是得到一個新的列表，且其每一個元素符合過濾原則。

例八、對列表的每一個元素應用函數

咱們一般須要對列表的每一個元素使用某個函數，例如逐一乘以某個數、除以某個數或者作其它操做。這些操做都很適合用 map() 方法，能夠將轉換邏輯以lambda表達式的形式放在 map() 方法裏，就能夠對集合的各個元素進行轉換了，以下所示。

// 將字符串換成大寫並用逗號連接起來
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
System.out.println(G7Countries); 
複製代碼

輸出：

USA, JAPAN, FRANCE, GERMANY, ITALY, U.K., CANADA 
複製代碼

例九、複製不一樣的值，建立一個子列表

本例展現瞭如何利用流的 distinct() 方法來對集合進行去重。

// 用全部不一樣的數字建立一個正方形列表
List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
System.out.printf("Original List : %s, Square Without duplicates : %s %n", numbers, distinct); 
複製代碼

輸出：

Original List : [9, 10, 3, 4, 7, 3, 4],  Square Without duplicates : [81, 100, 9, 16, 49] 
複製代碼

例十、計算集合元素的最大值、最小值、總和以及平均值

IntStream、LongStream 和 DoubleStream 等流的類中，有個很是有用的方法叫作 summaryStatistics() 。能夠返回 IntSummaryStatistics、LongSummaryStatistics 或者 DoubleSummaryStatistics，描述流中元素的各類摘要數據。在本例中，咱們用這個方法來計算列表的最大值和最小值。它也有 getSum() 和 getAverage() 方法來得到列表的全部元素的總和及平均值。

//獲取數字的個數、最小值、最大值、總和以及平均值
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest prime number in List : " + stats.getMax());
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum());
System.out.println("Average of all prime numbers : " + stats.getAverage());
複製代碼

輸出：

Highest prime number in List : 29
Lowest prime number in List : 2
Sum of all prime numbers : 129
Average of all prime numbers : 12.9
複製代碼

Lambda表達式 vs 匿名類

既然lambda表達式即將正式取代Java代碼中的匿名內部類，那麼有必要對兩者作一個比較分析。一個關鍵的不一樣點就是關鍵字 this。匿名類的 this 關鍵字指向匿名類，而lambda表達式的 this 關鍵字指向包圍lambda表達式的類。另外一個不一樣點是兩者的編譯方式。Java編譯器將lambda表達式編譯成類的私有方法。使用了Java 7的 invokedynamic 字節碼指令來動態綁定這個方法。

Java 8 Lambda表達式要點

10個Java lambda表達式、流API示例

到目前爲止咱們看到了Java 8的10個lambda表達式，這對於新手來講是個合適的任務量，你可能須要親自運行示例程序以便掌握。試着修改要求建立本身的例子，達到快速學習的目的。我還想建議你們使用Netbeans IDE來練習lambda表達式，它對Java 8支持良好。當把代碼轉換成函數式的時候，Netbeans會及時給你提示。只需跟着Netbeans的提示，就能很容易地把匿名類轉換成lambda表達式。此外，若是你喜歡閱讀，那麼記得看一下Java 8的lambdas，實用函數式編程這本書（Java 8 Lambdas, pragmatic functional programming），做者是Richard Warburton，或者也能夠看看Manning的Java 8實戰（Java 8 in Action），這本書雖然還沒出版，但我猜線上有第一章的免費pdf。不過，在你開始忙其它事情以前，先回顧一下Java 8的lambda表達式、默認方法和函數式接口的重點知識。

1）lambda表達式僅能放入以下代碼：預約義使用了 @Functional 註釋的函數式接口，自帶一個抽象函數的方法，或者SAM（Single Abstract Method 單個抽象方法）類型。這些稱爲lambda表達式的目標類型，能夠用做返回類型，或lambda目標代碼的參數。例如，若一個方法接收Runnable、Comparable或者 Callable 接口，都有單個抽象方法，能夠傳入lambda表達式。相似的，若是一個方法接受聲明於 java.util.function 包內的接口，例如 Predicate、Function、Consumer 或 Supplier，那麼能夠向其傳lambda表達式。

2）lambda表達式內可使用方法引用，僅當該方法不修改lambda表達式提供的參數。本例中的lambda表達式能夠換爲方法引用，由於這僅是一個參數相同的簡單方法調用。

list.forEach(n -> System.out.println(n)); 
list.forEach(System.out::println);  // 使用方法引用 
複製代碼

然而，若對參數有任何修改，則不能使用方法引用，而需鍵入完整地lambda表達式，以下所示：

list.forEach((String s) -> System.out.println("*" + s + "*")); 
複製代碼

事實上，能夠省略這裏的lambda參數的類型聲明，編譯器能夠從列表的類屬性推測出來。

3）lambda內部可使用靜態、非靜態和局部變量，這稱爲lambda內的變量捕獲。

4）Lambda表達式在Java中又稱爲閉包或匿名函數，因此若是有同事把它叫閉包的時候，不用驚訝。

5）Lambda方法在編譯器內部被翻譯成私有方法，並派發 invokedynamic 字節碼指令來進行調用。可使用JDK中的 javap 工具來反編譯class文件。使用 javap -p 或 javap -c -v 命令來看一看lambda表達式生成的字節碼。大體應該長這樣：

private static java.lang.Object lambda$0(java.lang.String);
複製代碼

6）lambda表達式有個限制，那就是隻能引用 final 或 final 局部變量，這就是說不能在lambda內部修改定義在域外的變量。

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});
int factor = 2;
primes.forEach(element -> { factor++; }); 

Compile time error : "local variables referenced from a lambda expression must be final or effectively final"
複製代碼

另外，只是訪問它而不做修改是能夠的，以下所示：

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});
int factor = 2;
primes.forEach(element -> { System.out.println(factor*element); }); 
複製代碼

輸出：

4
6
10
14 
複製代碼

所以，它看起來更像不可變閉包，相似於Python。

以上就是Java 8的lambda表達式的所有10個例子。這次修改將成爲Java史上最大的一次，將深遠影響將來Java開發者使用集合框架的方式。我想規模最類似的一次修改就是Java 5的發佈了，它帶來了不少優勢，提高了代碼質量，例如：泛型、枚舉、自動裝箱（Autoboxing）、靜態導入、併發API和變量參數。上述特性使得Java代碼更加清晰，我想lambda表達式也將進一步改進它。我在期待着開發並行第三方庫，這可使高性能應用變得更容易寫。

歡迎關注知乎專欄《跟上Java8》，分享優秀的Java8中文指南、教程，同時歡迎投稿高質量的文章。