Lambda表达式

lambda表达式

一、什么是λ表达式

λ表达式本质上是一个匿名方法：

public int add(int x, int y) {
        return x + y;
    }

转成λ表达式后是这个样子：

 (int x, int y) -> x + y;

参数类型也可以省略，Java编译器会根据上下文推断出来：

 (x, y) -> x + y; //返回两数之和   或    (x, y) -> { return x + y; } //显式指明返回值

可见λ表达式由三部分组成：参数列表，箭头（->），以及一个表达式或语句块

下面这个例子里的λ表达式没有参数，也没有返回值（相当于一个方法接受0个参数，返回void，其实就是Runnable里run方法的一个实现）：

 () -> { System.out.println("Hello Lambda!"); }

如果只有一个参数且可以被Java推断出类型，那么参数列表的括号也可以省略:

list -> { return list.size(); }

二、λ表达式的类型（它是Object吗？）

λ表达式可以被当做是一个Object（注意措辞）。λ表达式的类型，叫做“目标类型（target type）”。λ表达式的目标类型是“函数式接口

（functional interface）”，这是Java8新引入的概念。它的定义是：一个接口，如果只有一个显式声明的抽象方法，那么它就是一个函数

式接口。一般用@FunctionalInterface标注出来（也可以不标）

你可以用一个λ表达式为一个函数式接口赋值：

Runnable r1 = () -> {System.out.println("Hello Lambda!");};

然后再赋值给一个Object：

Object obj = r1;

但却不能这样干：

 Object obj = () -> {System.out.println("Hello Lambda!");}; // ERROR! Object is not a functional interface!

必须显式的转型成一个函数式接口才可以：

 Object o = (Runnable) () -> { System.out.println("hi"); }; // correct

一个λ表达式只有在转型成一个函数式接口后才能被当做Object使用。所以下面这句也不能编译：

System.out.println( () -> {} ); //错误! 目标类型不明

必须先转型:

System.out.println( (Runnable)() -> {} ); // 正确

一个λ表达式其实就是定义了一个匿名方法，只不过这个方法必须符合至少一个函数式接口。

三、λ表达式与集合类批处理操作（或者叫块操作）

Java8之前集合类的迭代（Iteration）都是外部的，即客户代码。而内部迭代意味着改由Java类库来进行迭代，而不是客户代码。例如：

 for(Object o: list) { // 外部迭代
        System.out.println(o);
    }

可以写成：

list.forEach(o -> {System.out.println(o);}); //forEach函数实现内部迭代

集合类（包括List）现在都有一个forEach方法，对元素进行迭代（遍历），所以我们不需要再写for循环了。forEach方法接受一个函数式接口Consumer做参数，所以可以使用λ表达式

Java8为集合类引入了另一个重要概念：流（stream）。一个流通常以一个集合类实例为其数据源，然后在其上定义各种操作。流的API设计使用了管道（pipelines）模式。对流的一次操作会返回另一个流。如同IO的API或者StringBuffer的append方法那样，从而多个不同的操作可以在一个语句里串起来。看下面的例子：

 List<Shape> shapes = ...
    shapes.stream()
      .filter(s -> s.getColor() == BLUE)
      .forEach(s -> s.setColor(RED));

先调用stream方法，以集合类对象shapes里面的元素为数据源，生成一个流。然后在这个流上调用filter方法，挑出蓝色的，返回另一个流。最后调用forEach方法将这些蓝色的物体喷成红色。（forEach方法不再返回流，而是一个终端方法，类似于StringBuffer在调用若干append之后的那个toString）

四、λ表达式的更多用法

4.1、嵌套的λ表达式

 Callable<Runnable> c1 = () -> () -> { System.out.println("Nested lambda"); };
 c1.call().run();

4.2、用在条件表达式中

 Callable<Integer> c2 = true ? (() -> 42) : (() -> 24);
 System.out.println(c2.call());

4.3定义一个递归函数，注意须用this限定

    protected UnaryOperator<Integer> factorial = i -> i == 0 ? 1 : i * this.factorial.apply( i - 1 );
    ...
    System.out.println(factorial.apply(3));

在Java中，随声明随调用的方式是不行的，比如下面这样，声明了一个λ表达式(x, y) -> x + y，同时企图通过传入实参(2, 3)来调用它：

int five = ( (x, y) -> x + y ) (2, 3); // ERROR! try to call a lambda in-place

Java的λ表达式只能用作赋值、传参、返回值等。

五、 其它相关概念

5.1、 捕获（Capture）

捕获的概念在于解决在λ表达式中我们可以使用哪些外部变量（即除了它自己的参数和内部定义的本地变量）的问题。

在Java8中，内部类和λ表达式都可以访问effectively final的本地变量。λ表达式的例子如下：

 int tmp1 = 1; //包围类的成员变量
    static int tmp2 = 2; //包围类的静态成员变量
    public void testCapture() {
        int tmp3 = 3; //没有声明为final，但是effectively final的本地变量
        final int tmp4 = 4; //声明为final的本地变量
        int tmp5 = 5; //普通本地变量
       
        Function<Integer, Integer> f1 = i -> i + tmp1;
        Function<Integer, Integer> f2 = i -> i + tmp2;
        Function<Integer, Integer> f3 = i -> i + tmp3;
        Function<Integer, Integer> f4 = i -> i + tmp4;
        Function<Integer, Integer> f5 = i -> {
            tmp5  += i; // 编译错！对tmp5赋值导致它不是effectively final的
            return tmp5;
        };
        ...
        tmp5 = 9; // 编译错！对tmp5赋值导致它不是effectively final的
    }
    ...

Java要求本地变量final或者effectively final的原因是变量作用域和多线程问题。

5.2、方法引用（Method reference）

任何一个λ表达式都可以代表某个函数式接口的唯一方法的匿名描述符。我们也可以使用某个类的某个具体方法来代表这个描述符，叫做方法引用。例如：

Integer::parseInt //静态方法引用
System.out::print //实例方法引用
Person::new       //构造器引用

下面是一组例子，教你使用方法引用代替λ表达式：

//c1 与 c2 是一样的（静态方法引用）
    Comparator<Integer> c2 = (x, y) -> Integer.compare(x, y);
    Comparator<Integer> c1 = Integer::compare;
//下面两句是一样的（实例方法引用1）
    persons.forEach(e -> System.out.println(e));
    persons.forEach(System.out::println);
 //下面两句是一样的（实例方法引用2）
    persons.forEach(person -> person.eat());
    persons.forEach(Person::eat);
//下面两句是一样的（构造器引用）
    strList.stream().map(s -> new Integer(s));
    strList.stream().map(Integer::new);
	super::toString //引用某个对象的父类方法
    String[]::new //引用一个数组的构造器

5.3、默认方法（Default method）

Java8中，接口声明里可以有方法实现了，叫做默认方法。在此之前，接口里的方法全部是抽象方法。

5.4、生成器函数（Generator function）

有时候一个流的数据源不一定是一个已存在的集合对象，也可能是个“生成器函数”。一个生成器函数会产生一系列元素，供给一个流。Stream.generate(Supplier s)就是一个生成器函数。其中参数Supplier是一个函数式接口，里面有唯一的抽象方法 get()。

下面这个例子生成并打印5个随机数：

Stream.generate(Math::random).limit(5).forEach(System.out::println);

注意这个limit(5)，如果没有这个调用，那么这条语句会永远地执行下去。也就是说这个生成器是无穷的。这种调用叫做终结操作，或者短路（short-circuiting）操作。