深入理解Java 8 Lambda表达式（Oracle官方文档版）-阿里云开发者社区

Java 8 问世三年了，9马上也要问世了，所以，嗯，我要开始学8了……

官方文档：http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

为什么用Lambda表达式

只是代码简洁了这个好处的话，并不能打动很多观众，java 8也不会这么令人期待，其实java 8引入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<Person>实例中。
本节首先介绍了这种用例的天真的方法。
它使用本地和匿名类改进了这种方法，然后使用lambda表达式使用高效简明的方法来完成。
方法1：创建搜索匹配一个特征的成员的方法

一种简单的方法是创建几种方法; 每个方法搜索符合一个特征的成员，如性别或年龄。以下方法打印比指定年龄更早的成员：

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

注意：A 集合是一个对象，该组中的多个元素到单个单元中。集合用于存储，检索，操纵和传达聚合数据。

这种方法可能会使您的应用程序变得脆弱，这是因为引入更新（例如较新的数据类型）而导致应用程序无法正常工作的可能性。假设您升级应用程序并更改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();
        }
    }
}

该方法通过调用该方法来检查参数中Person包含的每个实例是否满足参数中指定的搜索条件。如果方法返回一个值，那么该方法在实例上被调用。ListrosterCheckPersontestertester.testtester.testtrueprintPersonsPerson要指定搜索条件，您可以实现该 CheckPerson接口：

interface CheckPerson {
    boolean test(Person p);
}

以下类CheckPerson通过指定方法的实现来实现接口test。该方法可以筛选符合美国Selective Service的成员：true如果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表达式的标准功能接口

Reconsider the CheckPerson interface:

interface CheckPerson {
    boolean test(Person p);
}

这是一个非常简单的界面。它是一个功能界面，因为它只包含一个抽象方法。该方法需要一个参数并返回一个 boolean值。该方法非常简单，可能不值得在应用程序中定义一个。因此，JDK定义了几个标准的功能接口，您可以在包中找到它们java.util.function。
例如，您可以使用该 Predicate<T> 界面代替CheckPerson。该界面包含以下方法boolean test(T t)：


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

该接口Predicate<T>是通用接口的示例。通用类型（如通用接口）在尖括号（<>）中指定一个或多个类型参数。此接口只包含一个类型参数T。当您使用实际类型参数声明或实例化通用类型时，您将具有参数化类型。例如，参数化类型Predicate<Person>如下：

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

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

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

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

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

这不是使用lambda表达式的唯一可能的方法。以下方法建议使用lambda表达式的其他方法。
方法7：在整个应用程序中使用Lambda表达式
重新考虑printPersonsWithPredicate 使用lambda表达式的方法：

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

该方法检查参数中Person包含的每个实例是否满足参数中指定的条件。如果实例满足由此指定的条件，则该实例将调用该方法。ListrosterPredicatetesterPersontesterprintPersronPerson

而不是调用该方法printPerson，您可以指定在Person满足指定条件的那些实例上执行的其他操作tester。您可以使用lambda表达式指定此操作。假设你想要一个类似于一个lambda表达式printPerson，一个参数（一个类型的对象Person）并返回void。记住，要使用lambda表达式，您需要实现一个功能界面。在这种情况下，您需要一个包含抽象方法的功能界面，该方法可以使用一个类型的参数Person并返回void。该 Consumer<T> 界面包含void accept(T t)具有这些特征的方法。以下方法将p.printPerson()使用Consumer<Person>调用该方法的实例替换该调用 accept：

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

因此，以下方法调用与printPersons在方法3中调用的方法相同：在本地类中指定搜索条件代码以获取符合选择性服务的成员。用于打印成员的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，然后对该参数指定的操作执行操作block：

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);
        }
    }
}

以下方法从包含在roster哪些符合选择性服务的每个成员中检索电子邮件地址，然后打印：

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)
);

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

1.从集合中获取对象的源source。在此示例中，它Person从集合中获取对象的源roster。请注意，作为roster类型集合的集合也是类型List的对象Iterable。
1. 过滤与该Predicate对象匹配的对象tester。在此示例中，该Predicate对象是一个lambda表达式，用于指定哪些成员将具有选择性服务的资格。
3.映射由指定的每个经滤波的对象的值Function的对象mapper。在此示例中，该Function对象是一个返回成员的电子邮件地址的lambda表达式。
4.由指定执行每个映射对象的动作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执行的每个操作与相应的聚合操作：

操作filter，map并且forEach是聚合操作。从流中聚合操作流程元素，而不是直接从集合（这是在这个示例中调用的第一个方法的原因stream）。甲流是元素的序列。与集合不同，它不是存储元素的数据结构。相反，流携带来自源的值，例如通过管道的收集。甲管道是流的操作的序列，其在该示例中是filter- - 。map forEach另外，聚合操作通常接受lambda表达式作为参数，使您可以自定义它们的行为。

** GUI应用程序中的Lambda表达式**
要在图形用户界面（GUI）应用程序（如键盘操作，鼠标操作和滚动操作）中处理事件，您通常会创建事件处理程序，通常涉及实现特定接口。事件处理接口通常是功能接口; 他们往往只有一种方法。

 btn.setOnAction（new EventHandler <ActionEvent>（）{

            @Override 
            public void handle（ActionEvent event）{ 
                System.out.println（“Hello World！”）; 
            } 
        }）;

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

 btn.setOnAction（
           event  - > System.out.println（“Hello World！”） 
        ）;

Lambda表达式的语法

用括号括起来的逗号分隔的形式参数列表。该CheckPerson.test方法包含一个参数， p它表示Person该类的一个实例。

注意：您可以忽略lambda表达式中参数的数据类型。另外，如果只有一个参数，可以省略括号。例如，以下lambda表达式也是有效的：

p  - > p.getGender（）== Person.Sex.MALE 
    && p.getAge（）> = 18
    && p.getAge（）<= 25

箭头令牌， ->
一个由单个表达式或语句块组成的主体。此示例使用以下表达式：

p.getGender（）== Person.Sex.MALE 
    && p.getAge（）> = 18
    && p.getAge（）<= 25

如果指定单个表达式，则Java运行时将评估表达式，然后返回其值。或者，您可以使用return语句：

p -> {
    return p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25;
}

return语句不是表达式; 在lambda表达式中，您必须用大括号（{}）括起来。但是，您不必在大括号中包含一个void方法调用。例如，以下是有效的lambda表达式：

email -> System.out.println(email)

请注意，lambda表达式看起来很像一个方法声明; 您可以将lambda表达式视为匿名方法 - 没有名称的方法。

以下示例 Calculator是使用多个形式参数的lambda表达式的示例：

public class Calculator {
  
    interface IntegerMath {
        int operation(int a, int b);   
    }
  
    public int operateBinary(int a, int b, IntegerMath op) {
        return op.operation(a, b);
    }
 
    public static void main(String... args) {
    
        Calculator myApp = new Calculator();
        IntegerMath addition = (a, b) -> a + b;
        IntegerMath subtraction = (a, b) -> a - b;
        System.out.println("40 + 2 = " +
            myApp.operateBinary(40, 2, addition));
        System.out.println("20 - 10 = " +
            myApp.operateBinary(20, 10, subtraction));    
    }
}

该方法operateBinary对两个整数操作数进行数学运算。操作本身由一个实例指定IntegerMath。的例子中定义了lambda表达式两个操作，addition和subtraction。该示例打印以下内容：

40 + 2 = 42
20 - 10 = 10

访问封闭范围的局部变量

像本地和匿名类一样，lambda表达式可以捕获变量 ; 它们对包围范围的局部变量具有相同的访问权限。但是，与本地和匿名类不同，lambda表达式没有任何阴影问题（有关详细信息，请参阅阴影）。Lambda表达式是词法的范围。这意味着它们不会从超类型继承任何名称或引入新的范围界定。lambda表达式中的声明就像在封闭环境中一样被解释。以下示例 LambdaScopeTest演示如下：


import java.util.function.Consumer;

public class LambdaScopeTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            
            // The following statement causes the compiler to generate
            // the error "local variables referenced from a lambda expression
            // must be final or effectively final" in statement A:
            //
            // x = 99;
            
            Consumer<Integer> myConsumer = (y) -> 
            {
                System.out.println("x = " + x); // Statement A
                System.out.println("y = " + y);
                System.out.println("this.x = " + this.x);
                System.out.println("LambdaScopeTest.this.x = " +
                    LambdaScopeTest.this.x);
            };

            myConsumer.accept(x);

        }
    }

    public static void main(String... args) {
        LambdaScopeTest st = new LambdaScopeTest();
        LambdaScopeTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

T此示例生成以下输出：

x = 23
y = 23
this.x = 1
LambdaScopeTest.this.x = 0

如果在lambda表达式的声明中替换参数x，编译器将生成一个错误：ymyConsumer

Consumer<Integer> myConsumer = (x) -> {
    // ...
}

编译器生成错误“变量x已经在方法methodInFirstLevel（int）中定义”，因为lambda表达式不会引入新的一级范围。因此，您可以直接访问封闭范围的字段，方法和局部变量。例如，lambda表达式直接访问x该方法的参数methodInFirstLevel。要访问包围类中的变量，请使用关键字this。在这个例子中，this.x指的是成员变量FirstLevel.x。

然而，像本地和匿名类一样，lambda表达式只能访问最终或有效最终的封闭块的局部变量和参数。例如，假设您在methodInFirstLevel定义语句之后立即添加以下赋值语句：

void methodInFirstLevel(int x) {
    x = 99;
    // ...
}

由于这个赋值语句，变量FirstLevel.x不再是有效的最终了。因此，Java编译器会生成类似于“lambda表达式引用的本地变量必须是final”或“final”的错误消息，其中lambda表达式myConsumer尝试访问该FirstLevel.x变量：

System.out.println（“x =”+ x）;

目标打字

你如何确定一个lambda表达式的类型？
回想一下选择的男性和18至25岁之间的成员的lambda表达：

p - > p.getGender（）== Person.Sex.MALE
&& p.getAge（）> = 18
&& p.getAge（）<= 25

public static void printPersons(List<Person> roster, CheckPerson tester)
在方法3：在局部类指定搜索条件码

public void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester)
在方法6：Lambda表达式使用标准的功能接口当Java运行时调用该方法时

printPersons，它期望数据类型CheckPerson，因此lambda表达式是这种类型的。但是，当Java运行时调用该方法时
printPersonsWithPredicate，它期待数据类型Predicate<Person>，因此lambda表达式是这种类型的。这些方法期望的数据类型称为目标类型。
要确定lambda表达式的类型，Java编译器将使用上下文的目标类型或其中找到lambda表达式的情境。
因此，您只能在Java编译器可以确定目标类型的情况下使用lambda表达式：

变量声明
分配
回报表
阵列初始化器
方法或构造函数参数
Lambda表达体
条件表达式， ?:
演员表达式
目标类型和方法参数

对于方法参数，Java编译器使用其他两种语言功能来确定目标类型：重载解析和类型参数推断。

考虑以下两个功能界面（ java.lang.Runnable和 java.util.concurrent.Callable<V>）：

public interface Runnable {
    void run();
}

public interface Callable<V> {
    V call();
}

该方法Runnable.run不返回值，而是Callable<V>.call。假设您已经invoke按照以下方法重载了该方法

void invoke(Runnable r) {
    r.run();
}

<T> T invoke(Callable<T> c) {
    return c.call();
}

在以下语句中将调用哪种方法？

String s = invoke（（） - >“done”）;

该方法invoke(Callable<T>)将被调用，因为该方法返回一个值; 该方法 invoke(Runnable)没有。在这种情况下，lambda表达式的类型() -> "done"是Callable<T>。

序列化

如果lambda表达式的目标类型及其捕获的参数是可序列化的，则可以序列化它。然而，像内部类一样，强烈地不鼓励lambda表达式的序列化。

深入理解Java 8 Lambda表达式（Oracle官方文档版）

为什么用Lambda表达式

只是代码简洁了这个好处的话，并不能打动很多观众，java 8也不会这么令人期待，其实java 8引入lambda迫切需求是因为lambda 表达式能简化集合上数据的多线程或者多核的处理，提供更快的集合处理速度

文章概览

Lambda表达式的理想用例

Lambda表达式的语法

目标打字

序列化

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

深入理解Java 8 Lambda表达式（Oracle官方文档版）

为什么用Lambda表达式

**只是代码简洁了这个好处的话，并不能打动很多观众，java 8也不会这么令人期待，其实java 8引入lambda迫切需求是因为lambda 表达式能简化集合上数据的多线程或者多核的处理，提供更快的集合处理速度 **

文章概览

Lambda表达式的理想用例

Lambda表达式的语法

目标打字

序列化

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

只是代码简洁了这个好处的话，并不能打动很多观众，java 8也不会这么令人期待，其实java 8引入lambda迫切需求是因为lambda 表达式能简化集合上数据的多线程或者多核的处理，提供更快的集合处理速度