Java 8 Lambda 表達式詳解

時間  2019-11-07
標籤 java lambda 表達式 詳解 欄目 Java 简体版
原文   原文鏈接

版權聲明：本文由吳仙傑創做整理，轉載請註明出處：http://www.javashuo.com/article/p-kqynqxyn-gp.htmljava

1. 引言

在 Java 8 之前，若咱們想要把某些功能傳遞給某些方法，總要去寫匿名類。之前註冊事件監聽器的寫法與下面的示例代碼就很像：shell

manager.addScheduleListener(new ScheduleListener() {
    @Override
    public void onSchedule(ScheduleEvent e) {        
        // Event listener implementation goes here...
    }
});

這裏咱們添加了一些自定義代碼到 Schedule 監聽器中，須要先定義匿名內部類，而後傳遞一些功能到 onSchedule 方法中。編程

正是 Java 在做爲參數傳遞普通方法或功能的限制，Java 8 增長了一個全新語言級別的功能，稱爲 Lambda 表達式。segmentfault

2. 爲何 Java 須要 Lambda 表達式

Java 是面向對象語言，除了原始數據類型之處，Java 中的全部內容都是一個對象。而在函數式語言中，咱們只須要給函數分配變量，並將這個函數做爲參數傳遞給其它函數就可實現特定的功能。JavaScript 就是功能編程語言的典範（閉包）。數組

Lambda 表達式的加入，使得 Java 擁有了函數式編程的能力。在其它語言中，Lambda 表達式的類型是一個函數；但在 Java 中，Lambda 表達式被表示爲對象，所以它們必須綁定到被稱爲功能接口的特定對象類型。閉包

3. Lambda 表達式簡介

Lambda 表達式是一個匿名函數（對於 Java 而言並不很準確，但這裏咱們不糾結這個問題）。簡單來講，這是一種沒有聲明的方法，即沒有訪問修飾符，返回值聲明和名稱。app

在僅使用一次方法的地方特別有用，方法定義很短。它爲咱們節省了，如包含類聲明和編寫單獨方法的工做。編程語言

Java 中的 Lambda 表達式一般使用語法是 (argument) -> (body)，好比：ide

(arg1, arg2...) -> { body }

(type1 arg1, type2 arg2...) -> { body }

如下是 Lambda 表達式的一些示例：函數式編程

(int a, int b) -> {  return a + b; }

() -> System.out.println("Hello World");

(String s) -> { System.out.println(s); }

() -> 42

() -> { return 3.1415 };

3.1 Lambda 表達式的結構

Lambda 表達式的結構：

  • Lambda 表達式能夠具備零個，一個或多個參數。
  • 能夠顯式聲明參數的類型，也能夠由編譯器自動從上下文推斷參數的類型。例如 (int a) 與剛纔相同 (a)。
  • 參數用小括號括起來，用逗號分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。
  • 空括號用於表示一組空的參數。例如 () -> 42。
  • 當有且僅有一個參數時，若是不顯式指明類型，則沒必要使用小括號。例如 a -> return a*a。
  • Lambda 表達式的正文能夠包含零條，一條或多條語句。
  • 若是 Lambda 表達式的正文只有一條語句，則大括號可不用寫，且表達式的返回值類型要與匿名函數的返回類型相同。
  • 若是 Lambda 表達式的正文有一條以上的語句必須包含在大括號（代碼塊）中，且表達式的返回值類型要與匿名函數的返回類型相同。

4. 方法引用

4.1 從 Lambda 表達式到雙冒號操做符

使用 Lambda 表達式，咱們已經看到代碼能夠變得很是簡潔。

例如，要建立一個比較器，如下語法就足夠了

Comparator c = (Person p1, Person p2) -> p1.getAge().compareTo(p2.getAge());

而後，使用類型推斷：

Comparator c = (p1, p2) -> p1.getAge().compareTo(p2.getAge());

可是，咱們可使上面的代碼更具表現力和可讀性嗎？咱們來看一下：

Comparator c = Comparator.comparing(Person::getAge);

使用 :: 運算符做爲 Lambda 調用特定方法的縮寫，而且擁有更好的可讀性。

4.2 使用方式

雙冒號（::）操做符是 Java 中的方法引用。 當們使用一個方法的引用時，目標引用放在 :: 以前，目標引用提供的方法名稱放在 :: 以後，即 目標引用::方法。好比：

Person::getAge;

在 Person 類中定義的方法 getAge 的方法引用。

而後咱們可使用 Function 對象進行操做：

// 獲取 getAge 方法的 Function 對象
Function<Person, Integer> getAge = Person::getAge;
// 傳參數調用 getAge 方法
Integer age = getAge.apply(p);

咱們引用 getAge，而後將其應用於正確的參數。

目標引用的參數類型是 Function<T,R>，T 表示傳入類型，R 表示返回類型。好比，表達式 person -> person.getAge();，傳入參數是 person，返回值是 person.getAge()，那麼方法引用 Person::getAge 就對應着 Function<Person,Integer> 類型。

5. 什麼是功能接口（Functional interface）

在 Java 中，功能接口（Functional interface）指只有一個抽象方法的接口。

java.lang.Runnable 是一個功能接口，在 Runnable 中只有一個方法的聲明 void run()。咱們使用匿名內部類實例化功能接口的對象，而使用 Lambda 表達式，能夠簡化寫法。

每一個 Lambda 表達式均可以隱式地分配給功能接口。例如，咱們能夠從 Lambda 表達式建立 Runnable 接口的引用，以下所示：

Runnable r = () -> System.out.println("hello world");

當咱們不指定功能接口時，這種類型的轉換會被編譯器自動處理。例如：

new Thread(
    () -> System.out.println("hello world")
).start();

在上面的代碼中，編譯器會自動推斷，Lambda 表達式能夠從 Thread 類的構造函數簽名（public Thread(Runnable r) { }）轉換爲 Runnable 接口。

@FunctionalInterface 是在 Java 8 中添加的一個新註解，用於指示接口類型，聲明接口爲 Java 語言規範定義的功能接口。Java 8 還聲明瞭 Lambda 表達式可使用的功能接口的數量。當您註釋的接口不是有效的功能接口時， @FunctionalInterface 會產生編譯器級錯誤。

如下是自定義功能接口的示例：

package com.wuxianjiezh.demo.lambda;

@FunctionalInterface
public interface WorkerInterface {

    public void doSomeWork();
}

正如其定義所述，功能接口只能有一個抽象方法。若是咱們嘗試在其中添加一個抽象方法，則會拋出編譯時錯誤。例如：

package com.wuxianjiezh.demo.lambda;

@FunctionalInterface
public interface WorkerInterface {

    public void doWork();
    public void doMoreWork();
}

錯誤：

Error:(3, 1) java: 意外的 @FunctionalInterface 註釋
  com.wuxianjiezh.demo.lambda.WorkerInterface 不是函數接口
    在 接口 com.wuxianjiezh.demo.lambda.WorkerInterface 中找到多個非覆蓋抽象方法

一旦定義了功能接口，咱們就能夠利用 Lambda 表達式調用。例如：

package com.wuxianjiezh.demo.lambda;

@FunctionalInterface
public interface WorkerInterface {

    public void doWork();
}

class WorkTest {

    public static void main(String[] args) {
        // 經過匿名內部類調用
        WorkerInterface work = new WorkerInterface() {
            @Override
            public void doWork() {
                System.out.println("經過匿名內部類調用");
            }
        };
        work.doWork();
        
        // 經過 Lambda 表達式調用
        // Lambda 表達式其實是一個對象。
        // 咱們能夠將 Lambda 表達式賦值給一個變量，就可像其它對象同樣調用。
        work = ()-> System.out.println("經過 Lambda 表達式調用");
        work.doWork();
    }
}

運行結果：

經過匿名內部類調用
經過 Lambda 表達式調用

6. Lambda 表達式的例子

6.1 線程初始化

線程能夠初始化以下：

// Old way
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world");
    }
}).start();

// New way
new Thread(
    () -> System.out.println("Hello world")
).start();

6.2 事件處理

事件處理能夠用 Java 8 使用 Lambda 表達式來完成。如下代碼顯示了將 ActionListener 添加到 UI 組件的新舊方式：

// Old way
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Hello world");
    }
});

// New way
button.addActionListener( (e) -> {
        System.out.println("Hello world");
});

6.3 遍例輸出（方法引用）

輸出給定數組的全部元素的簡單代碼。請注意，還有一種使用 Lambda 表達式的方式。

// old way
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
for (Integer n : list) {
    System.out.println(n);
}

// 使用 -> 的 Lambda 表達式
list.forEach(n -> System.out.println(n));

// 使用 :: 的 Lambda 表達式
list.forEach(System.out::println);

6.4 邏輯操做

輸出經過邏輯判斷的數據。

package com.wuxianjiezh.demo.lambda;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Main {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

        System.out.print("輸出全部數字：");
        evaluate(list, (n) -> true);

        System.out.print("不輸出：");
        evaluate(list, (n) -> false);

        System.out.print("輸出偶數：");
        evaluate(list, (n) -> n % 2 == 0);

        System.out.print("輸出奇數：");
        evaluate(list, (n) -> n % 2 == 1);

        System.out.print("輸出大於 5 的數字：");
        evaluate(list, (n) -> n > 5);
    }

    public static void evaluate(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer n : list) {
            if (predicate.test(n)) {
                System.out.print(n + " ");
            }
        }
        System.out.println();
    }
}

運行結果：

輸出全部數字：1 2 3 4 5 6 7 
不輸出：
輸出偶數：2 4 6 
輸出奇數：1 3 5 7 
輸出大於 5 的數字：6 7

6.4 Stream API 示例

java.util.stream.Stream接口 和 Lambda 表達式同樣，都是 Java 8 新引入的。全部 Stream 的操做必須以 Lambda 表達式爲參數。Stream 接口中帶有大量有用的方法，好比 map() 的做用就是將 input Stream 的每一個元素，映射成output Stream 的另一個元素。

下面的例子，咱們將 Lambda 表達式 x -> x*x 傳遞給 map() 方法，將其應用於流的全部元素。以後，咱們使用 forEach 打印列表的全部元素。

// old way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
for(Integer n : list) {
    int x = n * n;
    System.out.println(x);
}

// new way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
list.stream().map((x) -> x*x).forEach(System.out::println);

下面的示例中，咱們給定一個列表，而後求列表中每一個元素的平方和。這個例子中，咱們使用了 reduce() 方法，這個方法的主要做用是把 Stream 元素組合起來。

// old way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = 0;
for(Integer n : list) {
    int x = n * n;
    sum = sum + x;
}
System.out.println(sum);

// new way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = list.stream().map(x -> x*x).reduce((x,y) -> x + y).get();
System.out.println(sum);

7. Lambda 表達式和匿名類之間的區別

  • this 關鍵字。對於匿名類 this 關鍵字解析爲匿名類，而對於 Lambda 表達式，this 關鍵字解析爲包含寫入 Lambda 的類。
  • 編譯方式。Java 編譯器編譯 Lambda 表達式時，會將其轉換爲類的私有方法，再進行動態綁定。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程