java中lambda運算式文法說明_java

文法說明

一個lambda運算式由如下幾個部分組成：

1. 在圓括弧中以逗號分隔的形參列表。在CheckPerson.test方法中包含一個參數p，代表了一個Person類的執行個體。注意：lambda運算式中的參數的類型是可以省略的；此外，如果只有一個參數的話連括弧也是可以省略的。比如上一節曾提到的代碼：

  p -> p.getGender() == Person.Sex.MALE  && p.getAge() >= 18      && p.getAge() <= 25

2. 箭頭符號：->。用來分隔參數和函數體。

3. 函數體。由一個運算式或代碼塊組成。在上一節的例子中使用了這樣的運算式：

p.getGender() == Person.Sex.MALE      && p.getAge() >= 18      && p.getAge() <= 25

如果使用的是運算式，java運行時會計算並返回運算式的值。另外，還可以選擇在代碼塊中使用return語句：

  p -> {    return p.getGender() == Person.Sex.MALE        && p.getAge() >= 18        && p.getAge() <= 25;  }

不過return語句並不是運算式。在lambda運算式中需要將語句用花括弧括起來，然而卻沒有必要在只是調用一個傳回值為空白的方法時也用花括弧括起來，所以如下的寫法也是正確的：

  email -> System.out.println(email)

lambda運算式和方法的聲明看起來有很多類似的地方。所以也可以把lambda運算式視為匿名方法，也就是沒有定義名字的方法。

以上提到的lambda運算式都是只使用了一個參數作為形參的運算式。下面的執行個體類，Caulator，示範了如何使用多個參數作為形參：

package com.zhyea.zytools;public class Calculator {  interface IntegerMath {    int operation(int a, int b);  }  public int operateBinary(int a, int b, IntegerMath op) {    return op.operation(a, b);  }  public static void main(String... args) {    Calculator myApp = new Calculator();    IntegerMath addition = (a, b) -> a + b;    IntegerMath subtraction = (a, b) -> a - b;    System.out.println("40 + 2 = " + myApp.operateBinary(40, 2, addition));    System.out.println("20 - 10 = " + myApp.operateBinary(20, 10, subtraction));  }}

代碼中operateBinary方法使用了兩個整型參數執行算數操作。這裡的算數操作本身就是IntegerMath介面的一個執行個體。在上面的程式中使用lambda運算式定義了兩個算數操作：addition和subtraction。執行程式會列印如下內容：

40 + 2 = 4220 - 10 = 10

訪問外部類的局部變數

類似於局部類或匿名類，lambda運算式也可以訪問外部類的局部變數。不同的是，使用lambda運算式時無需考慮覆蓋之類的問題。lambda運算式只是一個詞法上的概念，這意味著它不需要從超類中繼承任何名稱，也不會引入新的範圍。也就是說，在lambda運算式中的聲明和在它的外部環境中的聲明意義是一樣的。在下面的例子中對此作了示範：

package com.zhyea.zytools;import java.util.function.Consumer;public class LambdaScopeTest {  public int x = 0;  class FirstLevel {    public int x = 1;    void methodInFirstLevel(int x) {      //如下的語句會導致編譯器在statement A處報錯“local variables referenced from a lambda expression must be final or effectively final”      // x = 99;      Consumer<integer> myConsumer = (y) ->{        System.out.println("x = " + x); // Statement A        System.out.println("y = " + y);        System.out.println("this.x = " + this.x);        System.out.println("LambdaScopeTest.this.x = " + LambdaScopeTest.this.x);      };      myConsumer.accept(x);    }  }  public static void main(String... args) {    LambdaScopeTest st = new LambdaScopeTest();    LambdaScopeTest.FirstLevel fl = st.new FirstLevel();    fl.methodInFirstLevel(23);  }}

這段代碼會輸出如下內容：

x = 23y = 23this.x = 1LambdaScopeTest.this.x = 0

如果使用樣本中lambda運算式myConsumer中的參數y替換為x，編譯器就會報錯：

 

  Consumer<integer> myConsumer = (x) ->{        // ....      };

編譯器報錯資訊是：“variable x is already defined in method methodInFirstLevel(int)”，就是說在方法methodInFirstLevel中已經定義了變數x。報錯是因為lambda運算式不會引入新的範圍。也因此呢，可以在lambda運算式中直接存取外部類的域欄位、方法以及形參。在這個例子中，lambda運算式myConsumer直接存取了方法methodInFirstLevel的形參x。而訪問外部類的成員時也是直接使用this關鍵字。在這個例子中this.x指的就是FirstLevel.x。

然而，和局部類或匿名類一樣，lambda運算式也只能訪問局部變數或外部被聲明為final（或等同於final）的成員。比如，我們將範例程式碼methodInFirstLevel方法中“x=99”前面的注釋去掉：

      //如下的語句會導致編譯器在statement A處報錯“local variables referenced from a lambda expression must be final or effectively final”      x = 99;      Consumer<integer> myConsumer = (y) ->{        System.out.println("x = " + x); // Statement A        System.out.println("y = " + y);        System.out.println("this.x = " + this.x);        System.out.println("LambdaScopeTest.this.x = " + LambdaScopeTest.this.x);      };

因為在這段語句中修改了參數x的值，使得methodInFirstLevel的參數x不可以再被視為final式的。因此java編譯器就會在lambda運算式訪問局部變數x的地方報出類似“local variables referenced from a lambda expression must be final or effectively final”這樣的錯誤。

目標類型

該如何判斷lambda運算式的類型呢。再來看一下篩選適齡服兵役人員的代碼：

   p -> p.getGender() == Person.Sex.MALE          && p.getAge() >= 18          && p.getAge() <= 25

這段代碼在兩處用到過：

public static void printPersons(List<Person> roster, CheckPerson tester) —— 方案三
public void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester) —— 方案六

在調用printPersons方法時，這個方法期望一個CheckPerson 類型的參數，此時上面的那個運算式就是一個CheckPerson 類型的運算式。在調用printPersonsWithPredicate方法時，期望一個Predicate<Person>類型的參數，此時同樣的運算式就是Predicate<Person>類型的。像這樣子的，由方法期望的類型來決定的類型就叫做目標類型（其實我覺得scala中的類型推斷用在這裡更合適）。java編譯器就是通過目標類型的上下文語境或者發現lambda運算式時的位置來判斷lambda運算式的類型的。這也就意味著只能在Java編譯器可以推斷出類型的位置使用Lambda運算式：

1. 變數聲明；
2. 賦值；
3. 返回語句；
4. 數組初始化；
5. 方法或者構造器參數；
6. lambda運算式方法體；
7. 條件運算式（？：)；
8. 拋出異常時。
   

目標類型和方法參數

對於方法參數，Java編譯器還需要依賴兩個語言特性來決定目標類型：重載解析和型別參數推斷。

看一下下面的這兩個函數式介面( java.lang.Runnable and java.util.concurrent.Callable<V>)：

public interface Runnable {    void run();  }  public interface Callable<v> {    V call();  }

Runnable.run()方法沒有傳回值，而Callable.call()方法有。

假設我們像下面這樣重載了invoke方法：

 void invoke(Runnable r) {    r.run();  }  <t> T invoke(Callable<t> c) {    return c.call();  }

那麼在下面的語句中將會調用哪個方法呢：

String s = invoke(() -> "done");

調用的是invoke(Callable<T>)，因為這個方法有傳回值，而invoke(Runnable<T>)沒有傳回值。在這種情況下lambda運算式（() -> “done”）的類型是Callable<T>。

序列化

如果一個lambda運算式的目標類型還有它調用的參數的類型都是可序列化的，那麼lambda運算式也是可序列化的。然而就像內部類一樣，強烈不建議對lambda運算式進行序列化。