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
网友评论