本文是对官方文档的不完全翻译，如有错误请指正。

Lambda 表达式

匿名类的实现非常简单，例如只包含一个方法的接口，在这些情况下，您通常会尝试将函数作为参数传递给另一个方法，例如当有人单击按钮时应采取的操作。 Lambda 表达式使您能够做到这一点，将函数视为方法参数，或将代码视为数据。

对于只有一个方法的类，即使是匿名类也显得有些多余和繁琐。 Lambda 表达式让您可以更紧凑地表达单方法类的实例。

文章目录

Lambda 表达式
Lambda 表达式的理想用例
- 方法 1：创建搜索匹配一个特征的成员的方法
- 方法 2：创建更通用的搜索方法
- 方法 3：在本地类中指定搜索条件代码
- 方法 4：在匿名类中指定搜索条件代码
- 方法 5：使用 Lambda 表达式指定搜索条件代码
- 方法 6：使用带有 Lambda 表达式的标准函数式接口
- 方法 7：在整个应用程序中使用 Lambda 表达式
- 方法 8：更广泛地使用泛型
- 方法 9：使用接受 Lambda 表达式作为参数的聚合操作
GUI 应用程序中的 Lambda 表达式
- Lambda 表达式的语法
访问封闭范围的局部变量
- 目标类型
- - 目标类型和方法参数
- 序列化

Lambda 表达式的理想用例

假设您正在创建一个社交网络应用程序。您希望创建一个功能，使管理员能够对满足特定条件的社交网络应用程序的成员执行任何类型的操作，例如发送消息。下表详细描述了此用例：

字段	说明
名称	对选定成员执行操作
动作发起人	管理员
前提条件	管理员已登录系统
后置条件	仅对符合指定条件的成员执行操作
主要成功场景	管理员指定执行特定操作的成员标准。管理员指定对这些选定成员执行的操作。管理员选择提交按钮。系统查找所有符合指定条件的成员。系统对所有匹配的成员执行指定的操作。
扩展	管理员可以选择在指定要执行的操作之前或在选择提交按钮之前预览符合指定条件的成员
发生频率	一天中有很多次

假设此社交网络应用程序的成员由以下 Person 类表示：

public class Person {public enum Sex {MALE, FEMALE}String name;LocalDate birthday;Sex gender;String emailAddress;public int getAge() {// ...}public void printPerson() {// ...}
}

假设您的社交网络应用程序的成员存储在 List 实例中。

本节从对此用例的简单方法开始。它使用本地和匿名类改进了这种方法，然后使用 lambda 表达式以一种高效而简洁的方法结束。在示例 RosterTest 中找到本节中描述的代码摘录。

方法 1：创建搜索匹配一个特征的成员的方法

一种简单的方法是创建几种方法；每种方法都会搜索与某个特征（例如性别或年龄）相匹配的成员。以下方法打印超过指定年龄的成员：

public static void printPersonsOlderThan(List<Person> roster, int age) {for (Person p : roster) {if (p.getAge() >= age) {p.printPerson();}}
}

注意：列表是有序集合。集合是将多个元素组合成一个单元的对象。集合用于存储、检索、操作和通信聚合数据。有关集合的更多信息，请参阅集合跟踪。

这种方法可能会使您的应用程序变得脆弱，这是由于引入更新（例如更新的数据类型）而导致应用程序无法运行。假设您升级应用程序并更改 Person 类的结构，使其包含不同的成员变量；也许该类使用不同的数据类型或算法记录年龄。您将不得不重写很多 API 以适应这种变化。此外，这种方法具有不必要的限制性；例如，如果您想打印小于某个年龄的成员怎么办？

方法 2：创建更通用的搜索方法

下面的方法比 printPersonsOlderThan 更通用；它打印指定年龄范围内的成员：

public static void printPersonsWithinAgeRange(List<Person> roster, int low, int high) {for (Person p : roster) {if (low <= p.getAge() && p.getAge() < high) {p.printPerson();}}
}

如果要打印指定性别的成员，或指定性别和年龄范围的组合，该怎么办？如果您决定更改 Person 类并添加其他属性（例如关系状态或地理位置）怎么办？尽管此方法比 printPersonsOlderThan 更通用，但尝试为每个可能的搜索查询创建单独的方法仍然会导致代码脆弱。相反，您可以将指定要在不同类中搜索的条件的代码分开。

方法 3：在本地类中指定搜索条件代码

以下方法打印与您指定的搜索条件匹配的成员：

public static void printPersons(List<Person> roster, CheckPerson tester) {for (Person p : roster) {if (tester.test(p)) {p.printPerson();}}
}

此方法通过调用 tester.test 方法检查 List 参数 roster 中包含的每个 Person 实例是否满足 CheckPerson 参数 tester 中指定的搜索条件。如果 tester.test 方法返回真值，则在 Person 实例上调用 printPersons 方法。

要指定搜索条件，请实现 CheckPerson 接口：

interface CheckPerson {boolean test(Person p);
}

以下类通过指定方法 test 的实现来实现 CheckPerson 接口。此方法过滤在美国有资格参加选择性服务的成员：如果其 Person 参数为男性且年龄在 18 到 25 岁之间，则返回真值：

class CheckPersonEligibleForSelectiveService implements CheckPerson {public boolean test(Person p) {return p.gender == Person.Sex.MALE &&p.getAge() >= 18 &&p.getAge() <= 25;}
}

要使用这个类，你需要创建它的一个新实例并调用 printPersons 方法：

printPersons(roster, new CheckPersonEligibleForSelectiveService());

尽管这种方法不那么脆弱——如果你改变了 Person 的结构，你不必重写方法——你仍然有额外的代码：一个新的接口和一个本地类，用于你计划在应用程序中执行的每个搜索。因为 CheckPersonEligibleForSelectiveService 实现了一个接口，所以您可以使用匿名类而不是本地类，并且无需为每次搜索声明一个新类。

方法 4：在匿名类中指定搜索条件代码

下面调用 printPersons 方法的一个参数是一个匿名类，该类过滤在美国有资格参加选择性服务的成员：男性和 18 到 25 岁之间的成员：

printPersons(roster,new CheckPerson() {public boolean test(Person p) {return p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25;}}
);

这种方法减少了所需的代码量，因为您不必为要执行的每个搜索创建一个新类。但是，考虑到 CheckPerson 接口只包含一种方法，匿名类的语法很庞大。在这种情况下，您可以使用 lambda 表达式代替匿名类，如下一节所述。

方法 5：使用 Lambda 表达式指定搜索条件代码

CheckPerson 接口是一个功能接口。函数式接口是任何只包含一个抽象方法的接口。（一个函数式接口可能包含一个或多个默认方法或静态方法。）因为一个函数式接口只包含一个抽象方法，所以在实现它时可以省略该方法的名称。为此，您可以使用 lambda 表达式，而不是使用匿名类表达式，该表达式在以下方法调用中突出显示：

printPersons(roster,
(Person p) -> p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25
);

有关如何定义 lambda 表达式的信息，请参阅 Lambda 表达式的语法。

您可以使用标准函数式接口代替 CheckPerson 接口，这进一步减少了所需的代码量。

方法 6：使用带有 Lambda 表达式的标准函数式接口

重新考虑 CheckPerson 接口：

interface CheckPerson {boolean test(Person p);
}

这是一个非常简单的接口。它是一个函数式接口，因为它只包含一个抽象方法。此方法接受一个参数并返回一个布尔值。该方法非常简单，因此在您的应用程序中不值得定义它。因此，JDK 定义了几个标准函数式接口，您可以在包 java.util.function 中找到这些接口。

例如，您可以使用 Predicate 接口代替 CheckPerson。此接口包含方法 boolean test(T t)：

interface Predicate<T> {boolean test(T t);
}

接口 Predicate 是通用接口的一个示例。泛型在尖括号 (<>) 中指定一个或多个类型参数。此接口仅包含一个类型参数 T。当您使用实际类型参数声明或实例化泛型类型时，您就有了参数化类型。例如，参数化类型 Predicate 如下：

interface Predicate<Person> {boolean test(Person t);
}

此参数化类型包含一个与 CheckPerson.boolean test(Person p) 具有相同返回类型和参数的方法。因此，您可以使用 Predicate 代替 CheckPerson，如以下方法所示：

public static void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester) {for (Person p : roster) {if (tester.test(p)) {p.printPerson();}}
}

因此，以下方法调用与您在方法 3 中调用 printPersons 时相同：在本地类中指定搜索条件代码以获取有资格获得选择性服务的成员：

printPersonsWithPredicate(roster,p -> p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25
);

方法 7：在整个应用程序中使用 Lambda 表达式

重新考虑 printPersonsWithPredicate 方法，看看还有什么地方可以使用 lambda 表达式：

public static void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester) {for (Person p : roster) {if (tester.test(p)) {p.printPerson();}}
}

此方法检查 List 参数 roster 中包含的每个 Person 实例是否满足 Predicate 参数测试器中指定的条件。如果 Person 实例确实满足 tester 指定的条件，则在 Person 实例上调用 printPerson 方法。

除了调用 printPerson 方法，您还可以指定不同的操作来对那些满足 tester 指定标准的 Person 实例执行。您可以使用 lambda 表达式指定此操作。假设您想要一个类似于 printPerson 的 lambda 表达式，它接受一个参数（Person 类型的对象）并返回 void。请记住，要使用 lambda 表达式，您需要实现一个函数式接口。在这种情况下，您需要一个包含抽象方法的函数式接口，该方法可以接受一个 Person 类型的参数并返回 void。 Consumer 接口包含方法 void accept(T t)，它具有这些特性。以下方法将调用 p.printPerson() 替换为调用方法 accept 的 Consumer 的实例：

public static void processPersons(List<Person> roster, Predicate<Person> tester, Consumer<Person> block) {for (Person p : roster) {if (tester.test(p)) {block.accept(p);}}
}

因此，以下方法调用与您在方法 3 中调用 printPersons 时相同：在本地类中指定搜索条件代码以获取有资格获得选择性服务的成员。用于打印成员的 lambda 表达式被突出显示：

processPersons(roster,p -> p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25,p -> p.printPerson()
);

如果您想对会员的个人资料做更多的事情而不是打印出来怎么办。假设您要验证成员的个人资料或检索他们的联系信息？在这种情况下，您需要一个包含返回值的抽象方法的功能接口。 Function<T,R> 接口包含方法 R apply(T t)。以下方法检索参数mapper指定的数据，然后对其执行参数块指定的操作：

public static void processPersonsWithFunction(List<Person> roster,Predicate<Person> tester,Function<Person, String> mapper,Consumer<String> block) {for (Person p : roster) {if (tester.test(p)) {String data = mapper.apply(p);block.accept(data);}}
}

以下方法从名册中包含有资格参加选择性服务的每个成员中检索电子邮件地址，然后将其打印出来：

processPersonsWithFunction(roster,p -> p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25,p -> p.getEmailAddress(),email -> System.out.println(email)
);

方法 8：更广泛地使用泛型

重新考虑方法 processPersonsWithFunction。以下是它的通用版本，它接受包含任何数据类型元素的集合作为参数：

public static <X, Y> void processElements(Iterable<X> source,Predicate<X> tester,Function <X, Y> mapper,Consumer<Y> block) {for (X p : source) {if (tester.test(p)) {Y data = mapper.apply(p);block.accept(data);}}
}

要打印有资格参加选择性服务的成员的电子邮件地址，请调用 processElements 方法，如下所示：

processElements(roster,p -> p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25,p -> p.getEmailAddress(),email -> System.out.println(email)
);

此方法调用执行以下操作：

从集合source中获取对象。在此示例中，它从集合 roster 中获取 Person 对象。请注意，集合 roster 是 List 类型的集合，也是 Iterable 类型的对象。
过滤与Predicate类型的tester匹配的对象。在此示例中，Predicate的对象是一个 lambda 表达式，用于指定哪些成员有资格使用选择性服务。
遍历过滤后的由Function类型的mapper指定的对象的值。在此示例中，Function的对象是一个返回成员电子邮件地址的 lambda 表达式。
对遍历的每个对象执行由Consumer类型的block指定操作。在此示例中，Consumer 的对象是一个打印字符串的 lambda 表达式，该字符串是 Function 对象返回的电子邮件地址。

您可以将这些操作中的每一个替换为聚合操作。

方法 9：使用接受 Lambda 表达式作为参数的聚合操作

以下示例使用聚合操作来打印集合中符合选择性服务资格的成员的电子邮件地址：

roster.stream().filter(p -> p.getGender() == Person.Sex.MALE&& p.getAge() >= 18&& p.getAge() <= 25).map(p -> p.getEmailAddress()).forEach(email -> System.out.println(email));

下表映射了方法 processElements 执行的每个操作与相应的聚合操作：

processElements方法操作	聚合操作
获取源对象	Stream stream()
过滤匹配Predicate的对象	Stream filter(Predicate<? super T> predicate)
将对象映射到 Function 对象指定的另一个值	Stream map
(Function<? super T,? extends R> mapper)
执行Consumer对象指定的操作	void forEach(Consumer<? super T> action)

filter、map 和 forEach 是聚合操作。聚合操作处理来自流的元素，而不是直接来自集合（这就是本例中调用的第一个方法是流的原因）。流（Stream）是一系列元素。与集合不同，它不是存储元素的数据结构。相反，流通过管道（Pipline）从源（例如集合）携带值。管道是一系列流操作，在本例中为 filter-map-forEach。此外，聚合操作通常接受 lambda 表达式作为参数，使您能够自定义它们的行为方式。

GUI 应用程序中的 Lambda 表达式

要处理图形用户界面 (GUI) 应用程序中的事件，例如键盘操作、鼠标操作和滚动操作，您通常会创建事件处理程序（event handlers），这通常涉及实现特定接口。通常，事件处理程序接口（event handler interfaces）是函数式接口；他们往往只有一个方法。

例如把 JavaFX 示例 HelloWorld.java中的匿名类替换为 lambda 表达式：

public class HelloWorld extends Application {@Overridepublic void start(Stage primaryStage) {Button btn = new Button();btn.setText("Say 'Hello World'");btn.setOnAction(new EventHandler<ActionEvent>() {@Overridepublic void handle(ActionEvent event) {System.out.println("Hello World!");}});StackPane root = new StackPane();root.getChildren().add(btn);Scene scene = new Scene(root, 300, 250);primaryStage.setTitle("Hello World!");primaryStage.setScene(scene);primaryStage.show();}public static void main(String[] args) {launch(args);}
}

方法调用 btn.setOnAction 指定当您选择由 btn 对象表示的按钮时会发生什么。此方法需要 EventHandler 类型的对象。 EventHandler 接口只包含一个方法，void handle(T event)。该接口是一个函数式接口，因此您可以使用以下突出显示的 lambda 表达式来替换它：

btn.setOnAction(
event -> System.out.println("Hello World!"));