跳到主要内容
约 13 分钟3 张卡

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 一定比匿名内部类快吗?​

10.3 为什么循环变量有时可以被捕获?​

10.4 Lambda 可以序列化吗?​

11. 面试题卡片​

12. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明