Java 8 Lambda 表达式

Lambda 是啥玩意

简单来说，Lambda 就是一个匿名的方法，就这样，没啥特别的。它采用一种非常简洁的方式来定义方法。当你想传递可复用的方法片段时，匿名方法非常有用。例如，将一个方法传递给另外一个方法。

Tips
其实很多主流语言早已支持 lambda 表达式，例如，Scala，C#，Objective-C，Ruby，C++(11), Python等等。所以也不是啥新玩意儿。

匿名方法 VS 匿名类

需要谨记一点，在 Java 里，匿名方法和匿名类并不是相同的。匿名类仍然需要实例化对象，匿名类虽然没有明确的名字，但它只有是一个对象时才能够使用。
而匿名方法并不需要给它分配实例，方法与作用的数据分离，而对象与它所作用的数据密切相关。

Java 中的 Lambda 表达式

在 Java 8之前，一个实现了只有一个抽象方法的接口的匿名类看起来更像Lambda 表达式。下面的代码中，anonymousClass方法调用waitFor方法，参数是一个实现接口的Condition类，实现的功能为，当满足某些条件，Server 就会关闭。
下面的代码是典型的匿名类的使用。

void anonymousClass() {
    final Server server = new HttpServer();
    waitFor(new Condition() {
        @Override
        public Boolean isSatisfied() {
            return !server.isRunning();
        }
    }

下面的代码用 Lambda 表达式实现相同的功能：

void closure() { 
     Server server = new HttpServer();
     waitFor(() -> !server.isRunning()); 
 }

其实，上面的waitFor方法，更接近于下面的代码的描述：

class WaitFor {
    static void waitFor(Condition condition) throws   
    InterruptedException {
        while (!condition.isSatisfied())
            Thread.sleep(250);
    }
}

一些理论上的区别

实际上，上面的两种方法的实现都是闭包，后者的实现就是Lambda 表示式。这就意味着两者都需要持有运行时的环境。在 Java 8 之前，这就需要把匿名类所需要的一切复制给它。在上面的例子中，就需要把 server 属性复制给匿名类。

因为是复制，变量必须声明为 final 类型，以保证在获取和使用时不会被改变。Java 使用了优雅的方式保证了变量不会被更新，所以我们不用显式地把变量加上 final 修饰。

Lambda 表达式则不需要拷贝变量到它的运行环境中，从而 Lambda 表达式被当做是一个真正的方法来对待，而不是一个类的实例。

Lambda 表达式不需要每次都要被实例化，对于 Java 来说，带来巨大的好处。不像实例化匿名类，对内存的影响可以降到最小。

总体来说，匿名方法和匿名类存在以下区别：

• 类必须实例化，而方法不必；
• 当一个类被新建时，需要给对象分配内存；
• 方法只需要分配一次内存，它被存储在堆的永久区内；
• 对象作用于它自己的数据，而方法不会；
• 静态类里的方法类似于匿名方法的功能。

一些具体的区别

匿名方法和匿名类有一些具体的区别，主要包括获取语义和覆盖变量。

获取语义

this 关键字是其中的一个语义上的区别。在匿名类中，this 指的是匿名类的实例，例如有了内部类为Foo$InnerClass，当你引用内部类闭包的作用域时，像Foo.this.x的代码看起来就有些奇怪。
在 Lambda 表达式中，this 指的就是闭包作用域，事实上，Lambda 表达式就是一个作用域，这就意味着你不需要从超类那里继承任何名字，或是引入作用域的层级。你可以在作用域里直接访问属性，方法和局部变量。
例如，下面的代码中，Lambda 表达式可以直接访问firstName变量。

public class Example {
    private String firstName = "Tom";

    public void example() {
        Function addSurname = surname -> {
            // equivalent to this.firstName
            return firstName + " " + surname;  // or even,   
        };
    }
}

这里的firstName就是this.firstName的简写。
但是在匿名类中，你必须显式地调用firstName，

public class Example {
    private String firstName = "Jerry";

    public void anotherExample() {
        Function addSurname = new Function() {
            @Override
            public String apply(String surname) {
                return Example.this.firstName + " " + surname;   
            }
        };
    }
}

覆盖变量

在 Lambda 表达式中，

public class ShadowingExample {

    private String firstName = " Tim";

    public void shadowingExample(String firstName) {
        Function addSurname = surname -> {
            return this.firstName + " " + surname;
        };
    }
}

因为 this 在Lambda 表达式中，它指向的是一个封闭的作用域，所以this.firstName对应的值是“Tim”，而不是跟它同名的参数的值。如果去掉this，那么引用的则是方法的参数。

在上面的例子中，如果用匿名类来实现的话，firstName指的就是方法的参数；如果想访问最外面的firstName，则使用Example.this.firstName。

public class ShadowingExample {

    private String firstName = "King";

    public void anotherShadowingExample(String firstName) {
        Function addSurname = new Function() {
            @Override
            public String apply(String surname) {
                return firstName + " " + surname;
            }
        };
    }
}

Lambda 表达式基本语法

Lambda 表达式基本上就是匿名函数块。它更像是内部类的实例。例如，我们想对一个数组进行排序，我们可以使用Arrays.sort方法，它的参数是Comparator接口，类似于下面的代码。

Arrays.sort(numbers, new Comparator() {
    @Override
    public int compare(Integer first, Integer second) {
        return first.compareTo(second);
    }
});

参数里的Comparator实例就是一个抽象片段，本身没有别的。在这里只有在 sort 方法中被使用。
如果我们用新的语法来替换，用 Lambda 表达式的方式来实现：

Arrays.sort(numbers, (first, second) -> first.compareTo(second));

这种方式更加简洁，实际上，Java 把它当做Comparator类的实例来对待。如果我们把 sort的第二个参数从 Lambda 表达式中抽取出来，它的类型为Comparator。

Comparator ascending = (first, second) -> first.compareTo(second);
Arrays.sort(numbers, ascending);

语法分解

你可以把单一的抽象方法转换成 Lambda 表达式。
举例，如果我们有一个接口名为Example，里面只有一个抽象方法apply，该抽象方法返回某一类型。

interface Example {
     R apply(A args);
}

我们可以匿名实现此接口里的方法：

new Example() {
    @Override
    public R apply(A args) {
        body
    }
};

转换成 Lambda 表达式的话，我们去掉实例和声明，去掉方法的细节，只保留方法的参数列表和方法体。

(args) {
    body
}

我们引入新的符号（->）来表示 Lambda 表达式。

(args) -> {
    body
}

拿之前排序的方法为例，首先我们用匿名类来实现：

Arrays.sort(numbers, new Comparator() {
    @Override
    public int compare(Integer first, Integer second) {
        return first.compareTo(second);
    }
});

下一步，去掉实例和方法签名：

Arrays.sort(numbers, (Integer first, Integer second) {
    return first.compareTo(second);
});

引用 Lambda 表达式：

Arrays.sort(numbers, (Integer first, Integer second) -> {
    return first.compareTo(second);
});

完成！但有些地方可以进一步优化。你可以去掉参数的类型，编译器已经足够聪明知道参数的类型。

Arrays.sort(numbers, (first, second) -> {
    return first.compareTo(second);
});

如果是一个简单的表达式的话，例如只有一行代码，你可以去掉方法体的大括号，如果有返回值的话，return 关键字也可以去掉。

Arrays.sort(numbers, (first, second) -> first.compareTo(second));

如果Lambda 只有一个参数的话，参数外面的小括号也可以去掉。

(x) -> x + 1

去掉小括号后，

x -> x + 1

下一步我们做下总结，

(int x, int y) -> { return x + y; }
(x, y) -> { return x + y; }
(x, y) -> x + y; x -> x * 2
() -> System.out.println("Hello");
System.out::println;

第一个方式是完整的 Lambda 的声明和使用的方式，不过有些冗余，其实，参数的类型可以省略；
第二个方式是去掉参数类型的 Lambda 表达式；
第三个方式是，如果你的方法体只有一行语句，你可以直接省略掉大括号和 return 关键字；
第四个方式是没有参数的 Lambda 表达式；
第五个方式是Lambda 表达式的变种：是Lambda 表达式的一种简写，称为方法引用。例如：

 System.out::println;

实际上它是下面Lambda 表达式的一种简写：

(value -> System.out.prinltn(value)

深入 Lambda表达式

函数式接口

Java 把 Lambda表达式当作是一个接口类型的实例。它把这种形式被称之为函数式接口。一个函数式接口就是一个只有单一方法的接口，Java把这种方法称之为“函数式方法”，但更常用的名字为单一抽象方法（single abstract method" 或 SAM）。例如JDK中存在的接口例如Runnable和Callable。

@FunctionalInterface

Oracle 引入了一个新的注解为@FunctionalInterface， 用来标识一个接口为函数式接口。它基本上是用来传达这一用途，除此而外，编辑器还会做一些额外的检查。
比如，下面的接口：

public interface FunctionalInterfaceExample {
    // compiles ok
}

如果加上@FunctionalInterface注解，则会编译错误：

@FunctionalInterface // <- error here
    public interface FunctionalInterfaceExample {
      // doesn't compile
}

编译器就会报错，错误的详细信息为“Invalid '@FunctionalInterface' annotation; FunctionalInterfaceExample is not a functional interface”。意思是没有定义一个单一的抽象方法。
而如果我们定义了两个抽象方法会如何？

@FunctionalInterface
public interface FunctionalInterfaceExample {
    void apply();
    void illegal(); // <- error here
}

编译器再次报错，提示为"multiple, non-overriding abstract methods were found"。所以，一旦使用了此注解，则在接口里只能定义一个抽象方法。

而现在有这样一种情况，如歌一个接口继承了另一个接口，会怎么办？我们创建一个新的函数式接口为A，定义了另一个接口B，B继承A，则B仍然是一个函数式接口，它继承了A的apply方法。

@FunctionalInterface
interface A {
    abstract void apply();
}

interface B extends A {

如果你想看起来更加清晰，可以复写父类的方法：

@FunctionalInterface
interface A {
    abstract void apply();
}

interface B extends A {
    @Override
    abstract void apply();
}

我们可以用下面的代码来测试一下上面的两个接口是否为函数式接口：

@FunctionalInterface
public interface A {
    void apply();
}

public interface B extends A {
    @Override
    void apply();
}

public static void main(String... args) {
   A a = () -> System.out.println("A");
   B b = () -> System.out.println("B");
   a.apply(); // 打印：A
   b.apply(); // 打印：B
}

如果B接口继承了A接口，那么在B接口中就不能定义新的方法了，否则编译器会报错。

除了这些，在Java 8 中接口有了一些新的改进：

• 可以添加默认方法；
• 可以包含静态接口方法；
• 在java.util.function包中增加了一些新的接口，例如，Function 和 Predicate。

方法引用

简单来说，方法引用就是 Lambda 表达式的一种简写。当你创建一个 Lambda 表达式时，你创建了一个匿名方法并提供方法体，但你使用方法引用时，你只需要提供已经存在的方法的名字，它本身已经包含方法体。
它的基本语法如下；

Class::method

或一个更加简洁明了的例子：

String::valueOf

"::"符号前面表示的是目标引用，后面表示方法的名字。所以，在上面的例子，String 类作为目标类，用来寻找它的方法valueOf，我们指的就是 String 类上的静态方法。

public static String valueOf(Object obj) { ... }

"::"称之为定界符，当我们使用它的时候，只是用来引用要使用的方法，而不是调用方法，所以不能在方法后面加()。

String::valueOf(); // error

你不能直接调用方法引用，只是用来替代 Lambda 表达式，所以，哪里使用 Lambda 表达式了，哪里就可以使用方法引用了。
所以，下面的代码并不能运行：

public static void main(String... args) {
    String::valueOf;
}

这是因为该方法引用不能转化为Lambda 表达式，因为编译器没有上下文来推断要创建哪种类型的Lambda。
我们知道这个引用其实是等同于下面的代码：

(x) -> String.valueOf(x)

但编译器还不知道。虽然它可以知道一些事情。它知道，作为一个Lambda，返回值应该是字符串类型，因为valueOf方法的返回值为字符串类型。但它不知道作为论据需要提供什么信息。我们需要给它一点帮助，给它更多的上下文信息。
下面我们创建一个函数式接口Conversion，

@FunctionalInterface
interface Conversion {
    String convert(Integer number);
}

接下来我们需要创建一个场景去使用这个接口作为一个 Lambda，我们定义了下面的方法：

public static String convert(Integer number, Conversion function) {
    return function.convert(number);
}

其实，我们已经给编译器提供了足够多的信息，可以把一个方法引用转换成一个等同的 Lambda。当我们调用convert方法时，我们可以把如下代码传递给 Lambda。

convert(100, (number) -> String.valueOf(number));

我们可以用把上面的 Lambda 替换为方法引用，

convert(100, String::valueOf);

另一种方式是我们告诉编译器，把引用分配给一个类型：

Conversion b = (number) -> String.valueOf(number);

用方法引用来表示：

Conversion b = String::valueOf

方法引用的种类

在 Java 中，有四种方法引用的类型：

• 构造方法引用；
• 静态方法引用：
• 两种实例方法引用。

最后两个有点混乱。第一种是特定对象的方法引用，第二个是任意对象的方法引用，而是特定类型的方法引用。区别在于你想如何使用该方法，如果你事先并不知道有没有实例。

构造方法引用

构造方法的基本引用如下：

String::new

它会创建一个 Lambda 表达式，然后调用String 无参的构造方法。
它实际上等同于：

() -> new String()

需要注意的是构造方法引用没有括号，它只是引用，并不是调用，上面的例子只是引用了 String类的构造方法，并没有真正去实例化一个字符串对象。
接下来我们看一个实际应用构造方法引用的例子。
看先的例子，循环十遍为 list 增加对象。

public void usage() {
    List