java中lambda表达式语法说明

语法说明

一个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 = 42
20 - 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 = 23
y = 23
this.x = 1
lambdascopetest.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表达式进行序列化。