Java8 新特性(一) - Lambda

近些日子一直在使用和研究 golang，很长时间没有关心 java 相关的知识，前些天看到 java9 已经正式发布，意识到自己的 java 知识已经落后很多，心里莫名焦虑，决定将拉下的知识补上。

Lambda 表达式的渊源

Java8 作为近年来最重要的更新之一，为开发者带来了很多新特性，可能在很多其他语言中早已实现，但来的晚总比不来好。Lambda 表达式就是 Java8 带来的最重要的特性之一。

Lambda 表达式为 Java8 带来了部分函数式编程的支持。Lambda 表达式虽然不完全等同于闭包，但也基本实现了闭包的功能。和其他一些函数式语言不一样的是，Java 中的 Lambda 表达式也是对象，必须依附于一类特别的对象类型，函数式接口。

为什么需要 Lambda 表达式

内循环 VS. 外循环

先看一个非常简单的例子, 打印 list 内所有元素：

        List<Interger> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)

        for (int number: bumbers) {
            System.out.println(number)
        }

作为一个 Java 开发者，你这一生可能已经写过无数次类似代码。看上去好像挺好的，没有什么需要改进的，我们显式的在外部迭代遍历 list 内元素，并挨个处理其中元素。那为什么提倡内部迭代呢，因为内部迭代有助于 JIT 的优化，JIT 可以将处理元素的过程并行化。

在 Java8 之前，需要借助 Guava 或其他第三方库来实现内部迭代，而在 Java8 中， 我们可以用以下代码实现：

        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

以上代码还是稍显繁琐，需要创建一个匿名类，使用 lambda 表达式后，可以大大简化代码

        list.forEach((a) -> System.out.println(a));

Java 8 中 还引入了双冒号运算符，用于类方法引用，以上方法可以进一步简化为

        list.forEach(System.out::println);

内循环描述你要干什么，更符合自然语言描述的逻辑

passing behavior，not only value

通过 lambda 表达式，我们可以在传参时，不仅可以将值传入，还可将相关行为也传入，这样可以实现更加抽象和通用，更易复用的 API。看一下代码例子，需要实现一个求 list 内所有元素和的方法，嗯，看上去很简单。

public int sumAll(List<Integer> numbers) {
    int total = 0;
    for (int number : numbers) {
        total += number;
    }
    return total;
}

这个时候，又有需求实现一个 list 内所有偶数和的方法，简单，代码复制一遍，稍作修改。

public int sumAllEven(List<Integer> numbers) {
    int total = 0;
    for (int number : numbers) {
        if (number % 2 == 0) {
            total += number;
        }
    }
    return total;
}

也没发多少功夫，还需要改进么，这个时候又需要所有奇数和呢，不同的需求过来，你需要一遍又一遍的复制代码。有没有更加优雅的解决方法呢？我们又想起了我们的 lambda 表达式，java 8 引入了一个新的函数接口 Predicate<T>, 使用它来定义 filter，代码如下

public int sumAll(List<Integer> numbers, Predicate<Integer> p) {
    int total = 0;
    for (int number : numbers) {
        if (p.test(number)) {
            total += number;
        }
    }
    return total;
}

这样以上两个方法都可以通过这个方法实现，并且可以非常容易的扩展，当你需要用其他条件实现元素筛选求和时，只需要实现筛选条件的 lambda 表达式，如下

        System.out.println(sumAll(list, (a)-> true));           \\ 所有元素和
        System.out.println(sumAll(list, (a) -> a % 2 == 0));    \\ 所有偶数和
        System.out.println(sumAll(list, (a) -> a % 2 != 0));    \\ 所有奇数和

有同学会说，以前不用 lambda 表达式我们用接口也能实现。没错，用接口 + 匿名类也能实现类似效果，但 lambda 表达式更加直观，代码简捷，可读性也强，开发者也更有动力使用类似代码。

利于写出优雅可读性更高的代码

先看一段代码：

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        
        for (int number : list) {
            if (number % 2 == 0) {
                int n2 = number * 2;
                if (n2 > 5) {
                    System.out.println(n2);
                    break;
                }
            }
        }

这个代码也不难理解，取了 list 中的偶数，乘以 2 后 大于 5 的第一个数，这个代码看上去不难，但是当你在实际业务代码中添加更多的逻辑时，就会显得可读性较差。使用 Java 8 新加入的 stream api 和 lambda 表达式重构这段代码后，如下

        System.out.println(
                list.stream()
                        .filter((a) -> a % 2 == 0)
                        .map((b) -> b * 2)
                        .filter(c -> c > 5)
                        .findFirst()
        );

一行代码就实现了以上功能，并且可读性也好，从做至右依次读过去，先筛选 偶数，在乘以 2， 再筛选大于 5 的数，取第一个数。并且 stream api 都是惰性的api，且不占用多余的空间，比如上面这段代码，并不会把list 中所有元素都遍历，当找到第一个符合要求的元素后就会停止。

Lambda 表达式语法

Lambda 表达式的语法定义在 Java 8 规范 15.27 中，并给出了一些例子

() -> {}                    // 无参数，body 为空
() -> 42                    // 无参数，表达式的值作为返回
() -> {return 42;}          // 无参数，block 块
() -> {System.gc();}
() -> {
    if (true) return 23;
    else {
        return 14
    }
}
(int x) -> {return x + 1;}  // 有参数，且显式声明参数类型
(int x) -> x + 1            
(x) -> x + 1                // 有参数，未显式声明参数类型，编译器推断参数类型
x -> x + 1          
(int x, int y) -> x + y
(x, y) -> x + y         
(x, int y) -> x + y         // 非法, 参数类型显示指定不能混用

总结一下：

• Lambda 表达式可以具有零个，一个或多个参数。
• 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数类型。
• 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)
• 空括号用于表示一组空的参数。
• 当仅有一个参数时，且不显式指明类型，则可省略小括号
• Lambda 表达式的正文可以包含零条，一条或多条语句。
• 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写
• 如果 Lambda 表达式的正文有一条以上的语句必须包含在代码块中

Functional Interface (函数接口)

还有一个问题，在上面的内容没有提到，怎样在声明的时候表示 Lambda 表达式呢？比如函数可以接受一个Lambda表达式作为输入。Java 8 引入了一种新的概念，叫函数接口。其实说起来也不是什么新鲜东西，函数接口就是一种只包含一个抽象方法的接口（可以包含其他默认方法），同时 Java 8 引入一个新的注解 @FunctionalInterface,虽然不使用 FunctionalInterface 注解也可以使用，但是使用注解可以显式的声明该接口为函数接口，并且当接口不符合函数接口要求时，在编译期间抛出错误。之前 Java 已有的很多接口加上了该注解，最常见的比如 Runnable

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

也就是说，现在启动一个线程时，可以采用新的 Lambda 表达式

new Thread(
    () -> System.out.println("hello world")
).start()

之前已经存在的接口还有

java.lang.Comparable
java.util.concurrent.Callable

Java 8 中还新加了一些函数接口

java.util.function.Consumer<T>  // 消费一个元素，无返回
java.util.function.Supplier<T>  // 每次返回一个 T 类型的对象
java.util.function.Predicate<T> // 输入一个元素，返回 boolean 值，常用于 filter
java.util.function.Function<T,R> // 输入一个 T 类型元素，返回一个 R 类型对象

Lambda 表达式与匿名类

看上面的内容，一定会有人认为这些功能我使用匿名类也可以实现，那 Lambda 表达式和匿名类有什么区别呢。最明显的区别就是 this 指针，this 指针在匿名类中代表是匿名类，而在 Lambda 表达式中为包含 Lambda 表达式的类。同时，匿名类可以实现多个方法，而 Lambda 表达式只能有一个方法。
直观上，很多人会觉得 Lambda 表达式可能只是一个语法糖，最终转换为一个匿名类。事实上，考虑到实现效率问题，和向前兼容问题，Java 8 并没有采用匿名类语法糖，也没有和其他语言一样，采用专门的函数处理类型来实现 lambda 表达式。

lambda 实现

既然 lambda 表达式并未用匿名类的方式实现，那其原理到底是什么呢，之前我们分析泛型的时候都是分析字节码，这里也一样。我们先看一段代码和字节码。

public class LambdaStudy004 {
    public void print() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        list.forEach(x -> System.out.println(x));
    }
}

javap -p 结果

public class lambda.LambdaStudy004 {
  public lambda.LambdaStudy004();
  public void print();
  private static void lambda$print$0(java.lang.Integer);
}

很明显，lambda 表达式编译后，会生成类的一个私有静态方法，然而，事情并没有那么简单，虽然生成了一个静态方法，lambda 表达式本身又由什么表示呢，java 中没有函数指针，总要有一个类作为载体调用该静态方法。

javap -p -v 查看字节码

...

37: invokedynamic #5,  0              // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
42: invokeinterface #6,  2            // InterfaceMethod java/util/List.forEach:(Ljava/util/function/Consumer;)
47: return

...

和普通的 static 方法调用采用 invokestatic 指令不一样，lambda 表达式的调用采用了 java 7 新引入的 invokedynamic 指令，该指令是为了加强 java 的动态语言特性引入，当 invokedynamic 指令被调用时，会调用 metafactory 函数动态生成一个实现了函数接口的对象，该对象实现的方法实际调用了之前生成的 static 方法，这个对象才是 lambda 表达式的实际翻译后的表示，翻译代码如下

class LambdaStudy004Inner {
    private static void lambda$print$0(Integer x) {
        System.out.println(x);
    }

    private class lambda$1 implements Consumer<Integer> {
        @Override
        public void accept(Integer x) {
            LambdaStudy004Inner.lambda$print$0(x);
        }
    }

    public void print() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        list.forEach(new LambdaStudy004Inner().new lambda$1());
    }
}

具体引入 invokedynamic 实现 Lambda 表达是的原因可以看 R 大的解释, 传送门: Java 8的Lambda表达式为什么要基于invokedynamic

有疑问加站长微信联系（非本文作者）