三.Lambda表達式

1.簡介

 

在Java中，Lambda 表達式(lambda expression)是一個匿名函數。

 

Lambda表達式基於數學中的λ演算得名，直接對應於其中的Lambda抽象(lambda abstraction)，是一個匿名函數，即沒有函數名的函數。Lambda表達式可以表示閉包，但又不同於函數式語言的閉包。Lambda表達式讓代碼變得簡潔並且允許你傳遞行為，在java8出現之前傳遞行為的方法只有通過匿名內部類。

 

Lambda表達式的Java實現：第一個就是Lambda表達式自身，第二個是函數式接口。

 

Lambda表達式本質上就是一個匿名(即未命名的方法)。但是這個方法是不能獨立執行的，而是用於實現由函數式接口定義的一個方法（即：使用 Lambda 表達式實例化函數式接口）。因此，Lambda表達式會導致產生一個匿名類。

 

 

Lambda表達式不是獨立執行的，而是構成了一個函數式接口定義的抽象方法的實現，該函數式接口定義了它的目標類型。結果，只有在定義了lambda表達式的目標類型的上下文中，才能使用該表達式。當把一個lambda表達式賦給一個函數式接口的引用時，就創建了這樣的上下文。

當目標類型上下文中出現lambda表達式時，就會自動創建實現了函數式接口的一個類的實例(類似於匿名類)，函數式接口聲明的抽象方法的行為由lambda表達式定義。當通過目標調用該方法時，就會執行lambda表達式。

為了在目標類型上下文中使用lambda表達式，抽象方法的類型和lambda表達式的類型必須兼容。eg:如果抽象方法指定了兩個int類型的參數，那麼lambda表達式也必須執行兩個參數，其類型要麼被顯示指定為int類型，要麼在上下文中可以被隱式的推斷為int類型。總的來講，lambda表達式的參數的類型和數量必須與函數式接口內的抽象方法的參數兼容；返回類型必須兼容；並且lambda表達式可能拋出的異常必須能被該方法接受。

2.優點

Lambda表達式的應用使代碼變得更加緊湊，可讀性增強；Lambda表達式使並行操作大集合變得更方便，可以充分發揮多核CPU的優勢，更易於為多核處理器編寫代碼。

 

 

3.組成（或定義）

Lambda 表達式由三個部分組成：

 

 

第一部分為一個括號內用逗號分隔的形式參數，參數是函數式接口裡面方法的參數；

 

 

第二部分為一個箭頭符號：->；

 

 

第三部分為方法體，可以是表達式和代碼塊。

 

 

語法：

 

 

1）方法體為表達式，該表達式的值作為返回值返回。

 

 

(parameters)->expression

 

 

2）方法體為代碼塊，必須用{}來包裹起來，且需要一個return返回值，但若函數式接口裡面方法返回值是void，則無需返回值。

 

 

(parameters) -> { statements; }

 

 

Note:

1) 一個Lambda表達式可以有零個或多個參數

2) 參數的類型既可以明確聲明，也可以根據上下文來推斷。

eg：(int a)與(a)效果相同

3) 所有參數需包含在圓括號內，參數之間用逗號相隔。

eg：(a, b)或(int a, int b)或(String a, int b, float c)

4) 空圓括號代表參數集為空。

eg：() -> 50

5) 當只有一個參數，且其類型可推導時，圓括號（）可省略。

eg：a -> return a*a

6) Lambda表達式的主體可包含零條或多條語句

7) 如果Lambda表達式的主體只有一條語句，花括號{}可省略。匿名函數的返回類型與該主體表達式一致。

 

8) 如果 Lambda 表達式的主體包含一條以上語句，則表達式必須包含在花括號{}中（形成代碼塊）。匿名函數的返回類型與代碼塊的返回類型一致，若沒有返回則為空。

9)對於Lambda表達式中的多個參數，如果需要顯示聲明一個參數的類型，那麼必須為所有的參數都聲明類型。

eg：MyNumericTest是一個自定義函數式接口，詳情接口代碼略，看下面應用的例子：

這樣寫不合法：MyNumericTest isFactor = (int n,d) -> (n%d)==0;

正確的寫法：MyNumericTest isFactor = (int n,int d) -> (n%d)==0;

 

Lambda寫法示例：

eg：

1）左邊是指定類型的逗號分割的輸入列表，右邊是帶有return的代碼塊：

(intx,inty) -> {returnx + y; }

2）左邊是推導類型的逗號分割的輸入列表，右邊是返回值：

(x, y) -> x + y

3）左邊是推導類型的單一參數，右邊是一個返回值：

x -> x * x

4）左邊沒有輸入 (官方名稱: "burger arrow")，在右邊返回一個值：

() -> x

5）左邊是推導類型的單一參數，右邊是沒返回值的代碼塊（返回void）：

x -> { System.out.println(x); }

6）靜態方法引用：（注：第一次看不懂沒關系，後面會提到這種用法）

String::valueOf

7）非靜態方法引用：

Object::toString

8）繼承的函數引用：

x::toString

9）構造函數引用：

ArrayList::new

 

4.類型推斷

 

在Lambda表達式中，我們不需要明確指出參數類型，javac編譯器會通過上下文自動推斷參數的類型信息。根據上下文推斷類型的行為稱為類型推斷。

 

Java8提升了Java中已經存在的類型推斷系統，使得對Lambda表達式的支持變得更加強大。javac會尋找緊鄰lambda表達式的一些信息通過這些信息來推斷出參數的正確類型。

 

Note：在大多數情況下，javac會根據上下文自動推斷類型。假設因為丟失了上下文信息或者上下文信息不完整而導致無法推斷出類型，代碼編譯就不會通過。

 

JDK英文文檔：Generalized Target-Type Inference

 

 

5.Lambda 表達式的使用示例

（注：下面的例子若暫時看不懂，可通篇博客看完後再回過來看示例，第一次看難免會覺得不理解。）

1）無參Lambda表達式：

 

//函數式接口 
    interface MyNumber
    {
        double getValue();
    }

    class lambdaDemo
    {
        public static void main(String[] args)
        {
            MyNumber myNum;

            myNum = ()->123.45;
            System.out.println("A fixed value: "+myNum.getValue());

            myNum = ()->Math.random()*100;
            System.out.println("A random value: "+myNum.getValue());

            //下面情況是：lambda表達式的返回值類型與函數式接口中抽象函數的類型不匹配。
			// myNum = ()->"123.03"    //error! 
        }
    }

 

2）帶參數的lambda表達式：

 

interface NumericTest
    {
        boolean test(int n);
    }

    class lambdaDemo2
    {
        public static void main(String[] args)
        {
            NumericTest isEven = (n)->(n%2)==0;
            if(isEven.test(10)){
				System.out.println("10 is even");
			}
            if(!isEven.test(9)){
				System.out.println("9 is not even");
			}

            NumericTest isNonNeg = (n)-> n>=0;
            if(isNonNeg.test(1)){
				System.out.println("1 is non-negative");
			}
            if(!isNonNeg.test(-1)){
				System.out.println("-1 is negative");
			}
        }
    }

 

 

3）接受兩個參數的lambda表達式：

 

interface NumericTest2
    {
        boolean test(int n,int d);
    }

    class lambdaDemo3
    {
        public static void main(String[] args)
        {
            //測試一個數字是否是另一個數字的因子。
            NumericTest2 isFactor = (n,d) -> (n%d)==0;

            if(isFactor.test(10,2)){ 
				System.out.println("2 is a factor of 10");
			}
            if(!isFactor.test(10,3)){ 
				System.out.println("3 is not a factor of 10");
			}
        }
    }

 

 

4）線程優化：

原線程：

 

 new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello from thread");
            }
        }).start();

 

使用Lambda表達式：

 

new Thread(
                () -> System.out.println("Hello from thread")
        ).start();

 

5）事件處理

向一個 UI 組件添加 ActionListener

原java寫法：

 

button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("The button was clicked using old java code!");
            }
        });

 

使用Lambda表達式：

 

button.addActionListener((e) -> {
            System.out.println("The button was clicked. From Lambda expressions !");
        });

 

6)打印出給定數組中的所有元素

Note：使用 Lambda 表達式的方法不止一種。

原java寫法：

 

List list = Arrays.asList(1, 2, 3, 4, 5);
        for (Integer n : list) {
            System.out.println(n);
        }

使用Lambda表達式：

 

第一種方式：

 

List list = Arrays.asList(1, 2, 3, 4, 5);
        list.forEach(n -> System.out.println(n));

 

第二種方式：（這裡用到了方法引用）

 

List list = Arrays.asList(1, 2, 3, 4, 5);
        list.forEach(System.out::println);

 

7）使用斷言(Predicate)函數式接口創建一個測試，並打印所有通過測試的元素

代碼：

 

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class LambdaTest {
    public static void main(String[] a) {
        List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

        System.out.println("all numbers:");
        evaluate(list, (n) -> true);

        System.out.println("no numbers:");
        evaluate(list, (n) -> false);

        System.out.println("even numbers:");
        evaluate(list, (n) -> n % 2 == 0);

        System.out.println("odd numbers:");
        evaluate(list, (n) -> n % 2 == 1);

        System.out.println("numbers greater than 5:");
        evaluate(list, (n) -> n > 5);
    }
    public static void evaluate(List list, Predicate predicate) {
        for(Integer n: list)  {
            if(predicate.test(n)) {
                System.out.println(n + " ");
            }
        }
    }
}

結果顯示：

 

 

all numbers: 1 2 3 4 5 6 7 
no numbers: 
even numbers: 2 4 6 
odd numbers: 1 3 5 7 
numbers greater than 5: 6 7

 

8）Lambda 表達式打印數值中每個元素的平方

以下使用了 .stream() 方法將常規數組轉化為流。Java 8 新增加了流 APIs。java.util.stream.Stream接口包含許多有用的方法，能結合 Lambda 表達式產生非常棒的效果。我們將 Lambda 表達式x -> x*x傳給 map() 方法，該方法會作用於流中的所有元素。之後，我們使用 forEach 方法打印數據中的所有元素。

原java實現方式：

 

 List list = Arrays.asList(0,1,2,3,4,5);
        for(Integer n : list) {
            int x = n * n;
            System.out.println(x);
        }

 

使用Lambda表達式和Java8新特性 流 實現方式：

 

List list = Arrays.asList(0,1,2,3,4,5);
        list.stream().map((x) -> x*x).forEach(System.out::println);

 

9）計算給定數值中每個元素平方後的總和

原java實現方式：

 

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

 

使用Lambda表達式：

 

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

 

6.塊Lambda表達式