Lambda 表达式
Lambda 表达式用来实现函数式接口约定的行为,让一段处理逻辑可以作为参数传给方法,也可以作为返回值交出去。函数式接口只要求实现一个抽象方法,编译器就按这个方法检查 Lambda 的参数、返回值和受检异常。
理解 Lambda,要先确定它实现哪个接口,再分清创建函数对象和调用它的时刻。创建时保留了哪些值、调用时又会读取哪些状态,决定了变量捕获和方法引用的结果;this 指向谁,则要看 Lambda 所在的外层代码。
1. 面试核心
先记住这几条,再读正文- 函数式接口是只需要实现一个抽象方法的接口,Lambda 实现的就是这个方法;默认方法、静态方法不算在内。卡 · 函数式接口
- Lambda 的参数、返回类型和可抛出的受检异常,由目标类型的抽象方法决定,目标类型来自赋值、方法参数、返回值或强制转换。卡 · 目标类型
- Lambda 捕获的局部变量必须是
final或有效 final,也就是不能再赋值。捕获引用变量时,固定的是引用,引用指向的可变对象仍然可以修改。 - Lambda 里的
this指向外层对象,匿名内部类里的this指向匿名类实例自己。 - 绑定实例的方法引用在创建时就确定接收者,接收者为
null会立即抛出异常;把方法调用写进 Lambda 体时,要到调用 Lambda 才抛。卡 · 方法引用的求值时机
2. 函数式接口
函数式接口是只有一个需要实现的抽象方法、并且没有声明为 sealed 的接口。这个方法规定了行为的输入和输出:
@FunctionalInterface
public interface Converter<S, T> {
T convert(S source);
}
convert 接收 S、返回 T,Lambda 只要实现这一个转换。判断是不是函数式接口,数的是「还需要实现的抽象方法」,而不是接口里写了几行方法声明:
default、static和private方法自带实现,不计入。- 和
Object的公开方法签名相同的抽象声明(比如Comparator里的equals)也不计入,因为任何实现类都已经从Object继承了它。 - 多个父接口声明了签名相同、返回类型兼容的抽象方法时,它们合并成一个。
@FunctionalInterface 是可选注解,用来让编译器在接口声明处检查这些规则。不写注解,只要接口符合规则,也能作为 Lambda 的目标类型;写上后,如果有人新增了一个独立的抽象方法,编译器就会在接口处指出问题。
2.1 目标类型
目标类型是 Lambda 所在位置期望的函数式接口类型。编译器要先知道 Lambda 要实现哪个接口,才能检查这段代码写得对不对。赋值语句就可以提供这个类型:
Predicate<String> isBlank = value -> value.isBlank();
左边的 Predicate<String> 一次确定了三件事:
- 参数类型是
String。 - 返回类型是
boolean。 - Lambda 要实现的方法是
test。
所以 value 被推断为 String,isBlank() 返回的布尔值也正好符合接口要求。反过来说,单独一句 var f = value -> value.isBlank(); 是编译不过的,因为 Lambda 离开了接口就没有类型。除了赋值,方法参数、返回值和显式类型转换也能提供目标类型。
比如下面的方法声明返回 Predicate<String>,编译器就按这个接口检查 return 后面的 Lambda:
static Predicate<String> longerThan(int length) {
return value -> value.length() > length;
}
调用 longerThan(3) 得到一个判断函数,之后每次执行它,都检查字符串长度是否大于 3。方法已经返回了,length 却还能用,原因在外层变量捕获一节说明。
2.2 Lambda 与接口类型
同一段 Lambda 写法可以匹配不同的接口,但创建出来的对象各属各的接口:
Callable<String> task = () -> "done";
Supplier<String> supplier = () -> "done";
两段 Lambda 都没有参数、返回 "done",编译器分别按 Callable<String> 和 Supplier<String> 检查,都能通过。
但创建之后,task 就是一个 Callable,supplier 就是一个 Supplier,两者没有继承关系,不能把 task 直接赋给 Supplier<String> 类型的变量。两个接口的契约也不同:Callable.call() 声明了 throws Exception,Supplier.get() 没有。写法相同只说明这段代码同时满足两个接口的要求。
3. 常用函数式接口
选哪个函数式接口,看行为接收什么、返回什么。java.util.function 为这些输入输出组合提供了现成的接口:
| 接口 | 抽象方法 | 语义 |
|---|---|---|
Function<T, R> | R apply(T value) | 把 T 转换为 R |
Predicate<T> | boolean test(T value) | 判断条件 |
Consumer<T> | void accept(T value) | 消费值并产生副作用 |
Supplier<T> | T get() | 延迟提供值 |
UnaryOperator<T> | T apply(T value) | 同类型转换 |
BinaryOperator<T> | T apply(T left, T right) | 合并两个同类型值 |
下面通过方法引用实现其中四个接口。方法引用用 :: 指定一个已有方法,让它承担接口要求的行为;这里先看输入输出,接收者的区别见方法引用:
Function<User, String> name = User::displayName;
Predicate<User> active = User::active;
Consumer<User> audit = auditService::record;
Supplier<User> guest = User::guest;
这四个变量分别对应转换、判断、消费和提供结果:
name接收用户,返回显示名。active接收用户,返回是否活跃的布尔值。audit接收用户并记录审计信息,返回类型为void。guest在调用get()时才执行工厂方法,提供访客对象。
处理基本类型数据时,可以用 IntFunction、IntPredicate、IntConsumer 这类专门接口。它们直接接收 int,不用为了传参先把整数装箱成 Integer,可以减少装箱及其可能带来的对象分配。
3.1 函数组合
已有的判断和转换可以组合成新函数。比如先检查用户是否活跃、再检查年龄,或者先取显示名、再去掉首尾空格:
Predicate<User> activeAdult = User::active;
activeAdult = activeAdult.and(user -> user.age() >= 18);
Function<User, String> normalizedName = User::displayName;
normalizedName = normalizedName.andThen(String::trim);
and 要求两个判断都成立,和 && 一样会短路:第一个为 false 时不再执行第二个。andThen 把前一个函数的返回值交给后一个函数,所以先取显示名,再执行 trim。
组合适合简短的纯转换,也就是只根据输入算出输出、不改外部状态的行为。异常恢复、远程调用、多步状态修改这类逻辑对执行顺序有要求,串成一长条组合函数以后很难看清和调试,写成普通方法更合适。
4. 外层变量捕获
捕获是指 Lambda 使用了它外面定义的局部变量,并把这个变量的值保留下来。被捕获的局部变量必须是 final 或有效 final,后者指变量没写 final,但初始化之后再也没有被赋值:
int minimumLength = 3;
Predicate<String> accepted = value -> value.length() >= minimumLength;
// minimumLength = 5; // 编译错误:变量不再是有效 final
accepted 创建时捕获了 minimumLength 的值 3。如果取消最后一行的注释,minimumLength 被再次赋值,就不再是有效 final,编译器会在 Lambda 那一行报错。
这条限制让捕获的值保持稳定。前面的 longerThan(3) 返回后,方法调用已经结束,返回的 Lambda 却仍然可以使用保存下来的 3。它保留的是局部变量的值,不是一个能跟随外部赋值而变化的变量。要求局部变量不能再赋值,就避免了外面已经改成新值、Lambda 却仍使用旧值的歧义。
4.1 可变对象捕获
捕获引用变量不会复制它指向的对象,也不会让对象变成不可变。下面先用绑定实例的方法引用,观察共享列表的变化:
List<String> names = new ArrayList<>();
Consumer<String> addName = names::add;
addName.accept("Lin");
创建 names::add 时,方法引用就记下了 names 当时指向的列表。调用 addName.accept("Lin") 之后,这个列表里就有了 "Lin",外面通过 names 也能读到,因为两边用的是同一个对象。
这里有个细节:方法引用 names::add 在创建时就把 names 的值取走了,所以并不要求 names 是有效 final。改写成 Lambda name -> names.add(name) 以后,names 才算被捕获,需要满足有效 final。两种写法都可以修改列表内容。
修改外部对象是一种副作用,捕获规则不会替你处理它的线程安全问题。多个线程同时调用这个 Consumer,就是在并发修改同一个 ArrayList,仍需要同步或者让每个线程用自己的列表。
4.2 成员字段访问
字段不受有效 final 的限制,Lambda 可以读写当前对象的字段:
final class Counter {
private int value;
Runnable incrementer() {
return () -> value++;
}
}
原因是 Lambda 捕获的不是 value,而是外层的 Counter 对象,也就是 this。value++ 实际上是 this.value++,this 本身不会变,变的是对象的字段,所以不违反规则。每次调用返回的 Runnable,都会去读写这个对象当前的 value。
多个线程同时执行 value++ 时,读取、加一、写回三步可能互相交错,导致部分更新丢失。Lambda 不会为字段访问自动加锁,需要和普通方法一样做并发保护。
5. this 的含义
Lambda 不会像匿名内部类那样引入一个新的 this。在实例方法里创建 Lambda,里面的 this 与外层代码含义相同,都指向外层对象:
final class Service {
Runnable task() {
return () -> System.out.println(this.getClass().getSimpleName());
}
}
执行这个任务打印的是 Service,因为 this 就是创建任务的那个 Service 对象。换成匿名内部类,this 指向的是匿名类的实例,打印出来的会是空字符串(匿名类的简单类名为空)。所以把匿名内部类改写成 Lambda 时,如果代码里用了 this 或 super,要确认它们指向的对象是否跟着变了。
Lambda 实现对象的类名、对象身份和序列化形式属于实现细节。业务代码应依赖接口约定的行为,不能据此判断两个 Lambda 是否等价。
6. 方法引用
当 Lambda 的行为可以直接交给已有方法或构造器完成时,可以使用方法引用。按方法属于谁、接收者从哪里来,可以分成四种形式:
Function<String, Integer> parse = Integer::parseInt; // 静态方法
Supplier<String> getName = user::displayName; // 特定对象实例方法
Function<String, String> trim = String::trim; // 任意对象实例方法
Supplier<List<String>> listFactory = ArrayList::new; // 构造方法
实例方法的两种写法,区别在于有没有提前绑定对象。接收者就是调用实例方法的对象。user::displayName 已经绑定了 user,所以 getName.get() 不需要再传对象。String::trim 没有绑定对象,调用时传入的字符串才是接收者,相当于 value -> value.trim()。绑定实例的方法引用会在创建时计算接收者,它与对应 Lambda 的区别见方法引用的求值时机。
参数一一对应、意思直观时,方法引用更简洁;需要调整参数顺序、加条件或者处理异常时,写普通 Lambda 更清楚。
7. 异常与 Lambda
Lambda 体里抛出的受检异常,必须是目标接口方法声明允许的。这和普通方法一样:方法体抛出的受检异常要么在内部处理,要么写在 throws 里,而 Lambda 的 throws 就是接口方法的 throws:
Callable<String> callable = () -> Files.readString(path);
// Supplier<String> supplier = () -> Files.readString(path);
// 编译错误:Supplier.get 不声明 IOException
Files.readString(path) 声明了 IOException。Callable.call() 声明了 throws Exception,可以容纳它,所以第一行能编译;Supplier.get() 没有声明任何受检异常,注释里的赋值就编译失败。
需要把 I/O 失败往外传时,可以自己定义一个声明了 throws IOException 的函数式接口;也可以在 Lambda 里捕获异常,转换成有业务含义的异常,并把原异常作为 cause 保留下来。如果读文件和转换数据本来就是两步,把它们拆开,重试和恢复也更好处理。
受检异常的传播规则见 Java 异常。
8. 运行时实现
Lambda 不是匿名内部类的语法糖,编译后不会为每个 Lambda 生成一个 Outer$1.class 文件。OpenJDK 的 javac 把 Lambda 体编译成外层类里的一个私有方法,在创建 Lambda 的位置放一条 invokedynamic 指令。invokedynamic 是一种到运行时才决定调用目标的字节码指令:第一次执行到这里时,由 LambdaMetafactory 生成接口的实现类,之后这个位置就直接使用链接好的结果。
这对写代码的影响主要有一点:不要依赖 Lambda 对象的身份。没有捕获任何变量的 Lambda,运行时通常可以反复返回同一个实例;捕获了变量的 Lambda 需要保存捕获值,可能产生新对象。但语言规范对是否复用没有任何保证,所以不能用 == 判断两个 Lambda 是不是「同一个行为」。
日常开发关心目标类型和行为契约就够了。只有排查性能、字节码或框架兼容问题时,才需要深入 invokedynamic 和调用点的细节。
9. 方法引用的求值时机
方法引用和对应的 Lambda 看起来可以互换,但它们计算接收者的时刻不同:绑定实例的方法引用在创建时就计算接收者表达式,Lambda 体里的表达式要到调用时才计算。
String text = null;
// Supplier<Integer> first = text::length; // 创建时抛 NullPointerException
Supplier<Integer> second = () -> text.length(); // 创建成功
// second.get(); // 调用时抛 NullPointerException
text 是 null。如果取消 text::length 所在行的注释,求值这个方法引用 时就会检查接收者并抛出 NullPointerException。创建 second 时则只是捕获 text 的值,并不执行 text.length(),所以创建成功;直到调用 second.get(),才会因调用空引用的方法而抛出异常。
接收者不是 null 时,这个差别同样存在。holder.current::run 在创建时就固定了 current 字段当时指向的对象;() -> holder.current.run() 每次执行都重新读一次 current。如果字段在这期间换成了另一个对象,前者调用的是旧对象,后者调用的是新对象。同理,接收者表达式里如果有方法调用之类的副作用,前者只在创建时发生一次,后者每次调用都会发生。
10. 常见问题
10.1 函数式接口能有多个方法吗?
可以有多个方法,但需要实现的抽象方法只能有一个。默认、静态和私有方法自带实现,数量不限。从多个父接口继承来的同签名抽象方法,只要返回类型兼容,也算一个。如果两个抽象方法参数相同、返回类型却互不兼容,就合并不成一个方法,这个接口也就不是函数式接口。
10.2 Lambda 一定比匿名内部类快吗?
不一定,语法本身决定不了快慢。会不会分配对象、JIT(即时编译器)能不能内联优化,取决于有没有捕获变量、调用目标是否稳定,以及 JDK 版本。平时按 this 的含义、接口需求和可读性来选;真正的热点代码,用基准测试说话。
10.3 为什么循环变量有时可以被捕获?
因为增强 for 每次迭代都声明了一个新的局部变量,捕获的是当次迭代的值。只要循环体里不再给它赋值,它就是有效 final。普通 for 的 i++ 一直在修改同一个索引变量,所以不能直接捕获 i。解决办法是在循环体里先写 int index = i;,再捕获 index。
10.4 Lambda 可以序列化吗?
可以,但条件苛刻,也不建议依赖。目标类型要实现 Serializable(比如强制转换成 Runnable & Serializable),捕获的值也都要能序列化。序列化结果依赖编译器生成的实现细节,改动外层类的代码或换编译器都可能让旧数据反序列化失败,所以不适合当长期格式。要持久化一个任务,应该保存任务类型和业务参数,读回来以后再由代码重建行为。
11. 面试题卡片
12. 参考资料
- Java Language Specification:Lambda Expressions
- Java Language Specification:Functional Interfaces
- Java API:java.util.function
- Java API:FunctionalInterface
- Java API:LambdaMetafactory
- JLS:Method Reference Expressions
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明