1. 程式人生 > >Java 8 Lambda表示式使用詳解

Java 8 Lambda表示式使用詳解

1 引言

在 Java 8 以前,若我們想要把某些功能傳遞給某些方法,總要去寫匿名類。以前註冊事件監聽器的寫法與下面的示例程式碼就很像:

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

這裡我們添加了一些自定義程式碼到 Schedule 監聽器中,需要先定義匿名內部類,然後傳遞一些功能到 onSchedule 方法中。

正是 Java 在作為引數傳遞普通方法或功能的限制,Java 8 增加了一個全新語言級別的功能,稱為 Lambda 表示式。

2.為什麼 Java 需要 Lambda 表示式

Java 是面嚮物件語言,除了原始資料型別之處,Java 中的所有內容都是一個物件。而在函式式語言中,我們只需要給函式分配變數,並將這個函式作為引數傳遞給其它函式就可實現特定的功能。JavaScript 就是功能程式語言的典範(閉包)。

Lambda 表示式的加入,使得 Java 擁有了函數語言程式設計的能力。在其它語言中,Lambda 表示式的型別是一個函式;但在 Java 中,Lambda 表示式被表示為物件,因此它們必須繫結到被稱為功能介面的特定物件型別。

3.Lambda 表示式簡介

Lambda 表示式是一個匿名函式(對於 Java 而言並不很準確,但這裡我們不糾結這個問題)。簡單來說,這是一種沒有宣告的方法,即沒有訪問修飾符,返回值宣告和名稱。

在僅使用一次方法的地方特別有用,方法定義很短。它為我們節省了,如包含類宣告和編寫單獨方法的工作。

Java 中的 Lambda 表示式通常使用語法是 (argument) -> (body),比如:

(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 表示式的結構:

  1. Lambda 表示式可以具有零個,一個或多個引數。

  2. 可以顯式宣告引數的型別,也可以由編譯器自動從上下文推斷引數的型別。例如 (int a) 與剛才相同 (a)。

  3. 引數用小括號括起來,用逗號分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。

  4. 空括號用於表示一組空的引數。例如 () -> 42。

  5. 當有且僅有一個引數時,如果不顯式指明型別,則不必使用小括號。例如 a -> return a*a。

  6. Lambda 表示式的正文可以包含零條,一條或多條語句。

  7. 如果 Lambda 表示式的正文只有一條語句,則大括號可不用寫,且表示式的返回值型別要與匿名函式的返回型別相同。

  8. 如果 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 表示式,關鍵字解析為包含寫入 Lambda 的類。
編譯方式。Java 編譯器編譯 Lambda 表示式時,會將其轉換為類的私有方法,再進行動態繫結