Lambda Expressions(Lambda表达式)

最新推荐文章于 2024-08-09 20:53:55 发布

newsonglin

最新推荐文章于 2024-08-09 20:53:55 发布

阅读量3k

点赞数

分类专栏：编程技术

编程技术专栏收录该内容

19 篇文章 0 订阅

订阅专栏

有没有想过，如果匿名类非常简单，比方说一个接口仅有一个方法，实现这个接口的匿名类表达方式就显得很别扭。而且，往往在这种情况下，你是把一个匿名类作为参数传给另外一个方法使用的。因为匿名类经常是实现接口完成功能的，也就是说你要把一个功能作为参数传给另外一个方法，感觉怪怪的，不是吗（通常情况我们是传数据，不是传行为）？就好比，点击一个按钮要完成特定的功能这种情况。 Lambda表达式可以简化这些，它可以把功能当作参数，把代码调用当成数据在不同的地方传输。

在前一节，我们说过匿名类，就是说如何实现一个基类而不用指出子类名字。相对每个子类都要起个名字，这已经是比较简洁的做法了，然后对于只有一个方法的父类来说，这样仍然显得有点多余。Lambda表达式就是用来优美的实例化只有一个方法的类。

让我们来看一个Labda表达式使用的理想案例。

Labda表达式使用的理想案例

假定你正在创建一个社交网站，需要实现这样的功能：管理员能执行任何操作，其中一种操作就是能给符合条件的成员发送消息。下面的表格详细描述了该功能：

字段	描述
功能名字	对选定的成员执行相应的操作
主要执行角色	管理员
前置条件	管理员已经登陆进系统
后置条件	执行的操作只会应用到符合条件的成员上
主要的步骤	1.管理员指定要选出成员的条件 2.管理员对选定的成员发作操作指令 3.管理员选中提交按钮 4.系统后台查找所有符合条件的成员 5.系统对所有符合条件的会员执行相应操作
扩展场景	管理员在执行提交操作之前，能够预览他/她选中的符合条件的成员
发生频率	每天很多次

我们假定社交网站里的成员是用下面的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表达式来完成。想看代码的完整部分，点击这里RosterTest

实现方式1：创建方法来查找符合特定条件的成员

最最简单的方式就是创建它几个方法，每个方法查找符合特定条件的成员，例如根据性别或者年龄。下面的方法就可以输出年龄大于一定岁数的会员：

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

温馨提示：一个列表（List）就是一个有序的集合（Collection）. 集合就是把多个元素归并到一个单位，它就是用来存储、获取、操纵以及传输聚合性数据的。如果想要了解更多关于集合的信息，点击Collections

这种实现方式会使你的系统很脆弱，也就是说一旦有小的更新或者改动（例如引入新的数据类型），整个系统可能就不工作了。设想一下，如果你更新你的系统，把Person 的结构更改一下，增加新的成员变量或者计算年龄的算法变了。那你就不得不重写你的很多方法来满足此次更新。而且这个方案限制性太强，设想一下如果你想要输出年龄小于一定岁数的会员，怎么办？

实现方式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();
        }
    }
}

这个方法会检查列表参数roster 中的每一个Person 实例，看它是不是符合参数tester(CheckPerson类型） 所指定的条件。通过tester.test来调用检查，如果返回true,就是满足，然后person的printPerson方法就会被调用。

为了定义查询条件，你需要实现CheckPerson 接口:

interface CheckPerson {
    boolean test(Person p);
}

下面的类实现了接口CheckPerson, 实现了接口的test方法。这个方法会查出在美国适合服兵役的成员。方法会返回true, 如果成员是男性并且在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<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();
        }
    }
}

同样的，下面的方法调用，和你在实现方式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();
        }
    }
}

方法会遍历roster列表中的每个Person,看一下它是否满足tester里所指定的条件。如果条件满足， Person里面的printPerson方法就会被调用。

如果不调用方法printPerson,你可以给Person定义另外一种操作，当满足tester指定的条件，就执行此操作。可以用Lambda表达式来定义这个新操作。假定你想用Lambda表达式实现printPerson, 只有一个参数Person,并且返回空。别忘了，要用Lambda表达式，你需要实现一个函数接口。因此我们先要定义一个函数接口，它包含唯一的抽象方法，参数是Person,并且返回空。 Consumer<T> 接口包含了方法 void accept(T t) 刚好满足这种情况，真TM凑巧呀。接下来，我们就用Consumer<T> 的一个实例调用方法void accept(T t)来替换p.printPerson()

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 有一样的功效，输出适合服兵役的人。

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

下面的方法调用就会获取适合服兵役的会员邮件地址并且输出出来。

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

实现方案8：更惨无人道的使用泛型

让我们再来看看下面的方法，这是一个泛型的版本，它能接收一个数据集合为参数，这个数据集合可以包含任何类型的数据元素

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

我们来分析一下这个方法调用过程：

从集合（Collection) source中获取一个调用时传进来的源对象。在这个例子中，方法会从传进来roster获取到一个Person对象。注意roster是一个集合类型的列表，也是Iterable的对象类型。
然后开始过滤对象，要符合Predicate对象tester所指定的条件。在我们这个例子中，我们传的Predicate对象是一个Lambda表达式，它指定了需要服兵役的条件。
根据函数式对象Mapper, 把过滤的对象或者对象属性映射到另外一个具体的值或对象上。在我们这个例子中，函数式对象是一个Lambda表达式，会返回一个成员的电子邮件地址。
对每个映射的对象做相应的操作，这个操作是Consumer的对象block来定义的. 在我们的例子中，Consumer对象是一个Lambda表达式，它会输出一个字串，也就是函数式对象返回的电子邮件地址。

上面的每一个操作你都可以用聚合操作来代替。

实现方式9：使用聚合操作，把Lambda当作参数

下面的例子使用了聚合操作，它会把集合roster里面需要服兵役成员的邮件地址输出出来：

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<E> stream()`
过滤所有对象，查找出满足`Predicate`的对象	`Stream<T> filter(Predicate<? super T> predicate)`
根据Function功能，把对象映射到另外一个变量上	`<R> Stream<R> map(Function<? super T,? extends R> mapper)`
执行`Consumer`所指定的操作	`void forEach(Consumer<? super T> action)`

filter, map, 和 forEach都是聚合操作。聚合操作是操作一个流里的元素，而不是直接操作一个集合的元素（这也是为什么在例子中我们上来就调用stream方法的原因）。一个流就是一个元素序列。不像集合，它不是一个存储元素的数据结构。相反的，流通过管道存储了具体的值，例如来源于collection的值。一个管道有一系列的流操作，在这个例子中就是filter- map-forEach。而且聚合操作接受Lambda表达式作为参数，能够使你自定义操作行为。

如果想要了解更多的聚合操作，参照这里聚合操作

Lambda表达式在GUI(图形化操作界面)程序中的使用

在图形化界面的程序中，如果要处理事件，例如键盘操作、鼠标操作或者滚动操作, 典型的做法就是创建相应的事件处理程序（句柄），通常就是实现特定的接口。这样接口经常是函数式接口，因为只有一个方法需要实现。

在JavaFX的例子 HelloWorld.java 中，你可以把下面的匿名类用Lambda表达式替代。

        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表达式的语法

一个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在运行时会估算表达式并把结果返回，因此你也可以这样写：
```
p -> {
    return p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25;
}
```
请注意，一个返回语句不是表达式，你必须用{}包起来，然而如果一个方法返回的是空，你到是不需要用{}，例如，下面的是正确的：
```
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);
    }
}

上面的代码会输出以下结果：

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

如果你Lambda表达式括号定义的y换成x, 编译就会报错。
错误会提示：“变量x已经在方法methodInFirstLevel(int)里定义了”，因为Lambda表达式不会引入新一级的变量作用域。相应的，你可以直接访问包装这个Lambda表达式代码块内的字段、方法以及局部变量。例如Lambda表达式就可以直接访问方法methodInFirstLevel 的参数x。如果要访问包装它类内的变量，就用this。在这个例子中，this.x指的就是类成员变量FirstLevel.x。

然而，就如同局部类和匿名类一样，Lambda表达式只能访问final或者事实上是final的局部变量或者参数。例如，如果你在方法methodInFirstLevel定义之后加上一句赋值语句：

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

因为这个赋值语句，变量FirstLevel.x不再是事实上的final, 那么编译就会报错：Lambda表达式引用的局部变量必须是final或者事实上的final。报错的地方就是这里：

System.out.println("x = " + x);

目标决定类型

你怎么样判定一个Lambda表达式的类型？让我们回头看一下我们之前提到的Lambda表达式，用来选出年龄在18到25岁之间的男性成员。

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

这个Lambda表达式在下面两个方法里用到了：

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表达式的上下文或者情形下使用的目标类型来决定。也就说,Lambda表达式只能使用在java编译器可以判定出目标类型的地方：
- 变量声明时
- 赋值时
- 返回语句(Return)
- 数组初始化时
- 方法或者构造器的参数
- Lambda表达式的内容里
- 条件表达式 ？：
- 类型转换表达式 (Cast)

目标类型和方法参数

关于方法参数，Java编译器在判定目标类型的时候用到了语言的另外两个特性：重载解析和类型参数推断。
我们来看一下下面的两个函数式接口：( java.lang.Runnable 和java.util.concurrent.Callable)

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

那么下面的语句，哪一个invoke方法会被调用到？

String s = invoke(() -> "done");

invoke(Callable<T>) 方法会被调用到，因为这个方法是有返回值的方法。invoke(Runnable)方法不会被调用到。在这种情况下，Lambda表达式 () -> "done" 的数据类型就是Callable<T>

序列化

如果一个Lambda表达式的目标类型和携带参数都是可序列化的，你可以序列化这个Lambda表达式。然而，就像匿名类，强烈建议别瞎捣腾去序列化Lambda表达式。