Skip to content

7. 函数式接口、Lambda 与事件

在许多程序中,我们需要向方法传递的不是数据,而是行为:排序标准、过滤条件,或者在某件事发生时要执行的处理。Java 用一个简单的概念来满足这一需求,本章全部内容都以它为基础:函数式接口,即只声明一个抽象方法的接口。实现这种接口的对象“携带”着一个函数,该函数可以存放在变量中、作为参数传递、作为方法的结果返回,并可随时执行。

在 Java 8(2014 年)之前,对于想要表达的每一种行为,都必须编写一个类——通常是匿名类——这十分冗长。Java 8 引入了 lambda 表达式 和 方法引用,让您可以用一行代码写出这种行为。我们在第 5 章的流 API 中已经不加详述地用过它们:在 [persons.stream().filter(p -> p.age() >= 18)] 中,我们向 [filter] 方法传递了一个 lambda,即函数式接口的一个实例。本章将解释这种语法背后的原理。本章最后讲解 事件,Java 用“监听器”来处理事件:监听器是向发射器注册、以便获知其中所发生事情的对象——通常是 lambda。Java 图形用户界面(Swing、JavaFX)和 Web 框架都依赖这一机制:按钮点击或(HTTP)请求的到达,都会通知给已注册的监听器。本课程不涉及图形用户界面;所有示例都是控制台程序。

本章的程序是位于 [07-lambdas] 文件夹中的紧凑源文件。它们使用 [java LambdasNN.java] 运行。请注意,紧凑源文件会自动导入整个 [java.base] 模块:来自 [java.util.function]、[java.util] 或 [java.util.concurrent] 包的接口无需任何 [import] 语句即可使用。

7.1. 预定义的函数式接口

7.1.1. 函数式接口的概念

函数式接口 是恰好只有一个抽象方法的接口。它还可以拥有任意数量的 [default] 方法和 [static] 方法(见第 4 章):它们不计入。这个唯一的抽象方法描述了函数的一种模型(也称为签名或形式):其参数的类型和返回值的类型。于是,该接口类型的变量可以引用任何提供这种形式函数的对象,并通过调用该方法来执行它。

最古老的例子是 [java.lang.Runnable] 接口,它自 Java 1.0 起就已存在,表示一个待执行的任务(我们将在第 8 章讲线程时再回到它)。它只有一个方法:[void run();]。它描述的函数:

  • 没有参数;
  • 不返回结果([void])。

创建 [Runnable] 类型的对象有三种方式:

  • 编写一个实现该接口的类,具名或匿名均可。这是 Java 8 之前唯一的方式;
  • 编写一个 lambda 表达式:[Runnable task = () -> IO.println("task");];
  • 编写一个指向已有且形式正确的方法的 方法引用 :[Runnable task = Functions::display;]。

在后两种情况下,编译器会自行创建实现该接口的对象:lambda 或被引用的方法成为方法 [run] 的方法体。随后通过调用接口方法来执行该函数:[task.run()]。与其他语言不同,Java 没有专门的调用语法:始终通过名称调用接口方法([run]、[apply]、[test]……)。

7.1.2. java.util.function 包中的接口

在 Java 8 之前,每个库都定义自己的单方法接口([Runnable]、[Comparator]、[ActionListener]……)。Java 8 引入了 [java.util.function] 包,它提供 43 个泛型函数式接口,几乎涵盖了所有需求。主要的接口如下:

接口
抽象方法
所表示的函数
[Runnable] ([java.lang])
[void run()]
无参数,无结果
[Supplier<T>]
[T get()]
无参数,一个结果:“供应者”
[Consumer<T>]
[void accept(T t)]
一个参数,无结果:“消费者”
[BiConsumer<T, U>]
[void accept(T t, U u)]
两个参数,无结果
[Function<T, R>]
[R apply(T t)]
一个参数,一个类型为 [R] 的结果(始终是最后一个类型)
[BiFunction<T, U, R>]
[R apply(T t, U u)]
两个参数,一个结果
[UnaryOperator<T>]
[T apply(T t)]
一个 [Function<T, T>]:参数和结果类型相同
[BinaryOperator<T>]
[T apply(T t1, T t2)]
一个 [BiFunction<T, T, T>]
[Predicate<T>]
[boolean test(T t)]
一个参数,一个布尔结果:“谓词”
[BiPredicate<T, U>]
[boolean test(T t, U u)]
两个参数,一个布尔结果
[Comparator<T>] ([java.util])
[int compare(T o1, T o2)]
两个相同类型的参数,一个整数结果
[Callable<V>] ([java.util.concurrent])
[V call() throws Exception]
与 [Supplier<V>] 相同,但可以抛出受检异常

Java 泛型只适用于对象类型:[Function<Integer, Integer>] 接收并返回 [Integer],这需要在 [int] 和 [Integer] 之间进行自动转换(装箱 和 拆箱)。为了避免这些转换,该包为基本类型 [int]、[long], 和 [double] 提供了专门的版本:[IntBinaryOperator] ([int applyAsInt(int left, int right)])、[IntUnaryOperator]、[IntPredicate]、[IntSupplier]、[IntConsumer]、[IntFunction<R>] (以 [int] 作为参数)、[ToIntFunction<T>] (以 [int] 作为结果),以及它们对应的 [Long…] 和 [Double…] 版本。没有预定义的三个或更多参数的接口;在这种情况下,您必须自己定义(见下一段)。

程序 [Lambdas01.java] 通过方法引用使用这些接口:

// Java 预定义的函数式接口

void main() {
    // 1 - Runnable:无参数,无结果:void run()
    Runnable task = new Runnable() {
        @Override
        public void run() {
            Functions.display();
        }
    };
    // 简写形式:方法引用
    task = Functions::display;
    // 执行:我们调用接口唯一的抽象方法
    task.run();

    // 2 - BiFunction<T, U, R>:两个参数,一个结果
    BiFunction<Integer, Integer, Integer> operation = Functions::add;
    IO.println("operation.apply(2, 3)=" + operation.apply(2, 3));
    // Supplier<T>:无参数,一个结果
    Supplier<String> greet = Functions::greet;
    IO.println("greet.get()=" + greet.get());
    // 基本类型版本:IntBinaryOperator,int applyAsInt(int, int),无装箱
    IntBinaryOperator multiply = Functions::multiply;
    IO.println("multiply.applyAsInt(2, 3)=" + multiply.applyAsInt(2, 3));

    // 3 - Consumer<T>:一个参数,无结果
    Consumer<String> write = IO::println;
    write.accept("Consumer<String> executed IO.println");

    // 4 - Predicate<T>:一个参数,布尔结果
    Predicate<Integer> isEven = Functions::isEven;
    IO.println("isEven.test(8)=" + isEven.test(8));
    List<Integer> numbers = new ArrayList<>(List.of(3, 8, 1, 6, 5, 4));
    // Collection 的 removeIf 需要一个 Predicate
    boolean modified = numbers.removeIf(isEven);
    IO.println("even numbers removed: " + modified + ", remaining: " + numbers);

    // 5 - Comparator<T>:两个 T 参数,int 结果
    List<String> names = new ArrayList<>(List.of("Paul", "Mélanie", "Jo", "Sébastien"));
    names.sort(Functions::compareLengths);
    IO.println("sorted by length: " + names);

    // 6 - lambda 是对象:是实现该接口的生成类的实例
    IO.println("class: " + operation.getClass().getName());
    IO.println("interfaces: " + Arrays.toString(operation.getClass().getInterfaces()));
}

// 被引用的方法,归组在一个类中
// (精简源文件的隐式类无法被命名)
class Functions {

    static void display() {
        IO.println("display() executed by Runnable.run()");
    }

    static int add(int n1, int n2) {
        return n1 + n2;
    }

    static int multiply(int n1, int n2) {
        return n1 * n2;
    }

    static String greet() {
        return "Hello";
    }

    static boolean isEven(int n) {
        return n % 2 == 0;
    }

    static int compareLengths(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
}

结果:

> java Lambdas01.java
display() executed by Runnable.run()
operation.apply(2, 3)=5
greet.get()=Hello
multiply.applyAsInt(2, 3)=6
Consumer<String> executed IO.println
isEven.test(8)=true
even numbers removed: true, remaining: [3, 1, 5]
sorted by length: [Jo, Paul, Mélanie, Sébastien]
class: Lambdas01$$Lambda/0x0000000020165a28
interfaces: [interface java.util.function.BiFunction]

说明:

  • 第 5–10 行:创建 [Runnable] 对象,使用的是 匿名类——即没有名称的类,在需要的地方就地声明并实例化。它实现了 [run] 方法,该方法调用第 52 行的 [display] 方法。这是 Java 8 之前必须使用的语法;
  • 第 12 行:使用 方法引用 做同样的事:[Functions::display] 指向类 [Functions] 的静态方法 [display]。编译器验证它具有方法 [run] 的形式(无参数、无返回值),并创建调用它的 [Runnable] 对象。这是如今的标准语法;
  • 第 14 行:通过调用接口的方法来执行该函数。第 52 行的方法 [display] 被执行(结果的第 2 行);
  • 第 48–50 行:被引用的方法被归入一个名为 [Functions] 的类中。我们本想把它们直接写在文件里,紧挨着 [main],并命名为 [Lambdas01::add]。然而,包装紧凑源文件的隐式类无法在代码中被命名(编译器会返回 [cannot find symbol]);
  • 第 17 行:[BiFunction<Integer, Integer, Integer>] 指向一个有两个参数 [Integer], 并返回 [Integer] (最后一个泛型类型)的函数。第 56 行的方法 [add] 处理的是 [int],它是合适的:编译器会添加 [int] 和 [Integer] 之间的转换。该函数通过其方法 [apply] 调用(第 18 行);
  • 第 20 行:[Supplier<String>] 指向一个返回字符串的无参函数。它通过其方法 [get] 调用;
  • 第 23 行:基本类型版本 [IntBinaryOperator] 直接对 [int] 值进行操作,无需转换。它的方法名为 [applyAsInt]。对于计算密集型任务,这是首选类型;
  • 第 27 行:[Consumer<String>] 指向一个接受一个 [String], 参数且不返回任何内容的函数。静态方法 [IO.println(Object)] 是合适的:[String] 是一个 [Object]。它通过其方法 [accept] 执行;
  • 第 31 行:谓词是返回布尔值的函数;它通过其方法 [test] 执行(第 32 行)。接口 [removeIf] 的方法 [Collection] (第 35 行)需要一个类型为 [Predicate] 的参数:它会从集合中移除所有使谓词返回 [true] 的元素,并且如果至少移除了一个元素,就返回 [true] ;
  • 第 40 行:接口 [List] 的方法 [sort] 接受一个比较两个元素的 [Comparator] (结果可以为负、零或正,与 [compareTo] 类似)。这里,名字按长度升序排序。方法 [compareLengths] (第 72 行)使用 [Integer.compare],它比较两个 [int] 对象 而没有溢出的风险(简单的减法无法保证这一点);
  • 第 44–45 行:方法引用与 lambda 一样,也是一个对象。它的类(显示在结果的第 10 行)是由虚拟机在运行时生成的类,其名称包含 [$$Lambda] ,后面跟着一个每次执行都会变化的地址。在结果的第 11 行,我们看到这个类实现了 [BiFunction] 接口。因此,lambda 并不是一种新的对象类型:它是实现某个函数式接口的普通类的实例。

7.2. 定义自己的函数式接口

预定义的接口通常已经够用,但您也可以定义自己的接口。只需编写一个只有一个抽象方法的接口,例如:

  • [interface Operation { int calculate(int n1, int n2); }]

这个接口表示一个接受两个整数并返回一个整数的函数。与 [IntBinaryOperator]* 相比,类型 *[Operation] 的名称描述了其用途,它的方法有一个描述性的名称([calculate] 而不是 [applyAsInt]*),它的参数也有名称([n1]、[n2]),开发工具会显示这些名称。它前面带有注解 [@FunctionalInterface]*:这不是必需的,但它会指示编译器验证该接口是函数式接口,并且记录了开发者的意图。

类型为 [Operation] 的变量 [op] 一次只能引用 一个函数。与提供“多播委托”的其他语言不同,Java 没有提供把多个函数存放在一个变量中并通过一次调用执行它们的方式:需要时,会把函数放入一个 列表 并逐个执行。这正是我们处理事件监听器时要做的事。

来看示例 [Lambdas02.java]:

// 定义自己的函数式接口

void main() {
    // Operation 类型的变量接收静态方法 increase
    Operation op = Calculations::increase;
    // 我们执行该操作
    int n = op.calculate(4, 7);
    IO.println("n=" + n);

    // 创建 Calculations 类型的对象 c1
    var c1 = new Calculations();
    // 我们把对象 c1 的 add 方法存入 op
    op = c1::add;
    n = op.calculate(2, 3);
    IO.println("n=" + n);
    // 然后是 c1 的 subtract 方法
    op = c1::subtract;
    n = op.calculate(2, 3);
    IO.println("n=" + n);

    // 一个变量只引用一个函数:要执行多个函数,我们使用列表
    List<Operation> operations = new ArrayList<>();
    operations.add(c1::add);
    operations.add(c1::subtract);
    operations.add((n1, n2) -> n1 * n2);
    for (Operation operation : operations) {
        IO.println("-> " + operation.calculate(10, 4));
    }

    // 接口的 default 方法构建一个新操作
    Operation squaredSum = ((Operation) c1::add).then(x -> x * x);
    IO.println("squaredSum.calculate(1, 2)=" + squaredSum.calculate(1, 2));

    // Operation 和 IntBinaryOperator 形式相同,但是两种不同的类型
    IntBinaryOperator other = op::calculate;
    IO.println("other.applyAsInt(5, 1)=" + other.applyAsInt(5, 1));

    // 泛型函数式接口
    Transformation<String, Integer> length = String::length;
    Transformation<Integer, String> stars = "*"::repeat;
    IO.println("length(\"Hello\")=" + length.transform("Hello"));
    IO.println("stars(5)=" + stars.transform(5));
}

// 函数式接口的定义:只有一个抽象方法
// 接受两个整数作为参数并返回一个整数
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);

    // default 方法不计入:该接口仍然是函数式接口
    default Operation then(IntUnaryOperator next) {
        return (n1, n2) -> next.applyAsInt(calculate(n1, n2));
    }
}

// 泛型函数式接口:T -> R
@FunctionalInterface
interface Transformation<T, R> {
    R transform(T value);
}

// 其方法具有 Operation 接口形式的类
class Calculations {
    // 两个实例方法
    int add(int n1, int n2) {
        IO.println("add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }

    int subtract(int n1, int n2) {
        IO.println("subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }

    // 一个静态方法
    static int increase(int n1, int n2) {
        IO.println("increase(" + n1 + "," + n2 + ")");
        return n1 + 2 * n2;
    }
}

结果:

> java Lambdas02.java
increase(4,7)
n=18
add(2,3)
n=5
subtract(2,3)
n=-1
add(10,4)
-> 14
subtract(10,4)
-> 6
-> 40
add(1,2)
squaredSum.calculate(1, 2)=9
subtract(5,1)
other.applyAsInt(5, 1)=4
length("Hello")=5
stars(5)=*****

说明:

  • 第 47–55 行:函数式接口 [Operation] 的定义。在紧凑源文件中,类型声明(类、接口、记录等)可以放在方法 [main] 之前或之后;我们把它们放在之后;
  • 第 52–54 行:函数式接口可以有 [default] 方法。方法 [then] 构造一个新的 [Operation]:该方法先执行当前操作,然后对其结果应用函数 [next] 。它返回一个 lambda,我们将在下一节中考察。预定义接口的组合方法([andThen]、[compose]……等)都是按此模型编写的,我们稍后再讨论;
  • 第 64–81 行:类 [Calculations] 有两个实例方法 [add] 和 [subtract],以及一个静态方法 [increase],这三个方法的形式都与方法 [calculate] 相同;
  • 第 5 行:变量 [op] 的类型为 [Operation]。它被赋值为对静态方法 [Calculations.increase] 的引用;
  • 第 7 行:通过方法 [calculate] 执行该操作。方法 [Calculations.increase] 会被执行,传给 [calculate] 的参数会传递给它;
  • 第 11 行:创建类 [c1] 的实例 [Calculations] ;
  • 第 13 行:引用 [c1::add] 指向对象 [add] 的方法 [c1]。[increase] 是静态方法,而 [add] 是实例方法:这没有区别。在第二种情况下,编译器创建的对象还会保存将要调用该方法的对象 [c1] ;
  • 第 17 行:对实例方法 [subtract] 做同样的事;
  • 第 22–28 行:为了执行多个操作,把它们放入一个列表 [List<Operation>] 中,然后遍历该列表。方法引用和 lambda 可以混合使用(第 25 行)。每个结果都被取出(结果的第 8–12 行);
  • 第 31 行:对操作 [default] [then] 应用方法 [c1::add]。转换 [(Operation)] 是必需的:方法引用本身没有类型,在编译器知道它实现哪个接口之前,不能对它调用方法(我们稍后会回到这一点)。[squaredSum.calculate(1, 2)] 计算 (1+2)²,结果为 9(结果的第 13–14 行);
  • 第 35 行:[Operation] 和 [IntBinaryOperator] 的形式完全相同,但它们是两个不同的类型,没有继承关系。赋值 [IntBinaryOperator other = op;] 会被拒绝([incompatible types: Operation cannot be converted to IntBinaryOperator])。相反,方法引用 [op::calculate] 具有正确的形式:它创建一个 [IntBinaryOperator] ,该对象调用 [calculate] 方法,所属对象为 [op](在程序的这个阶段,即 [c1::subtract] );
  • 第 57–61 行:函数式接口可以是泛型的。[Transformation<T, R>] 表示一个接受 [T] 并返回 [R] 的函数:这等价于 [Function<T, R>],只是名称由我们自己选择;
  • 第 39 行:[String::length] 适用于 [Transformation<String, Integer>]:方法 [length] 将在作为参数传入的字符串上调用。第 40 行:["*"::repeat] 指向字符串对象 [repeat(int)] 的方法 ["*"];它接受一个整数并返回一个字符串。这是两种不同类型的方法引用,我们将在下一节详细讨论。

注解 [@FunctionalInterface] 在以下情况下发挥作用:不小心添加了第二个抽象方法,例如 [int invert(int n);],它被加入接口 [Operation] 中。编译器随后会标出该注解本身,以及每一个使用该接口的 lambda 和方法引用(输出已简化):

> java Lambdas02.java
Lambdas02.java:5: error: incompatible types: Operation is not a functional interface
    Operation op = Calculations::increase;
                   ^
    multiple non-overriding abstract methods found in interface Operation
...
Lambdas02.java:47: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  Operation is not a functional interface
    multiple non-overriding abstract methods found in interface Operation
9 errors
error: compilation failed

编译器 [javac] 的消息是英文的:JDK 不提供法语翻译。

7.3. 匿名类、lambda 表达式和方法引用

7.3.1. 从匿名类到 lambda

在前面的示例中,每个函数都是写在程序其他位置的具名方法。对于只使用一次的简短函数,这样做很麻烦。直到 Java 7,唯一的替代方案是 匿名类:实现接口的类就写在创建对象的地方。Java 8 引入了一种简洁得多的语法——lambda 表达式——对于函数式接口,它几乎已经取代了匿名类。程序 [Lambdas03.java] 演示了各种形式:

// 从匿名类到 lambda 表达式

void main() {
    // 1 - 匿名类:实现接口的类就地编写
    IntBinaryOperator add = new IntBinaryOperator() {
        @Override
        public int applyAsInt(int n1, int n2) {
            return n1 + n2;
        }
    };
    IO.println("anonymous class: add(2, 3)=" + add.applyAsInt(2, 3));

    // 2 - 用 lambda 表达式(Java 8)实现同样的功能:parameters -> body
    IntBinaryOperator subtract = (int n1, int n2) -> {
        return n1 - n2;
    };
    IO.println("block-body lambda: subtract(2, 3)=" + subtract.applyAsInt(2, 3));

    // 3 - 参数类型由目标接口推断
    IntBinaryOperator multiply = (n1, n2) -> n1 * n2;
    IO.println("expression-body lambda: multiply(2, 3)=" + multiply.applyAsInt(2, 3));

    // 4 - 单个参数:括号是可选的
    IntUnaryOperator square = x -> x * x;
    Predicate<String> isEmpty = s -> s.isEmpty();
    IO.println("square(7)=" + square.applyAsInt(7) + ", isEmpty(\"\")=" + isEmpty.test(""));

    // 5 - 无参数:空括号
    Supplier<String> greet = () -> "Hello";
    Runnable beep = () -> IO.println("beep!");
    IO.println(greet.get());
    beep.run();

    // 6 - 包含多条语句的块体
    BiConsumer<String, Integer> repeat = (text, times) -> {
        for (int i = 0; i < times; i++) {
            IO.print(text);
        }
        IO.println();
    };
    repeat.accept("ab", 3);

    // 7 - 未命名参数(Java 22):我们不需要它们的值
    BiConsumer<Object, String> listener = (_, _) -> IO.println("event received");
    listener.accept(null, "click");

    // 8 - 直接作为方法参数传递的 lambda
    List<Integer> numbers = new ArrayList<>(List.of(3, 8, 1, 6, 5, 4));
    List<Integer> evens = new ArrayList<>(numbers);
    evens.removeIf(n -> n % 2 != 0);
    IO.println("evens: " + evens);
    numbers.sort((n1, n2) -> Integer.compare(n2, n1));
    IO.println("descending order: " + numbers);
}

结果:

> java Lambdas03.java
anonymous class: add(2, 3)=5
block-body lambda: subtract(2, 3)=-1
expression-body lambda: multiply(2, 3)=6
square(7)=49, isEmpty("")=true
Hello
beep!
ababab
event received
evens: [8, 6, 4]
descending order: [8, 6, 5, 4, 3, 1]

说明:

  • 第 5–10 行:一个匿名类。运算符 [new] 后面跟着接口名称、空括号,以及实现该接口的类的主体。编译器会生成一个类(名称由它自行选择,[Lambdas03$1])并创建它的一个实例。用六行代码来表达 [n1 + n2];
  • 第 14–16 行:使用 lambda 表达式做同样的事。我们写出参数列表、[->] 运算符(箭头,读作“得到”),然后是主体。接口名称和方法名称都不见了:编译器可以从变量的类型得知它们,该类型称为 lambda 的 目标类型。主体是用花括号括起来的代码块的 lambda 称为 块体 lambda;
  • 第 20 行:参数类型不见了。编译器根据目标类型 [IntBinaryOperator] 推断它们:[n1] 和 [n2] 的类型是 [int]。主体简化为一个表达式,其值就是 lambda 的结果:这是 表达式体 lambda。这是最常见的形式;
  • 第 24 行:对于只有一个且未指定类型的参数,括号是可选的。[x -> x * x] 读作“x 得到 x 乘以 x”。第 25 行:一个带有一个 [String] 类型参数并返回布尔值的 lambda:它是一个 [Predicate<String>];
  • 第 29–30 行:没有参数时,使用空括号。主体为 [void] 类型方法调用的 lambda 适用于 [Runnable];
  • 第 35–40 行:块体 lambda 可以包含任何语句:声明、循环、判断等;
  • 第 44 行:下划线字符 [_] 表示 匿名参数 (Java 22)。当接口的签名要求有 lambda 并不需要的参数时就会用到它,这在事件监听器中很常见。同一个 lambda 中可以包含多个这样的参数;
  • 第 49–51 行:lambda 最常见的用法是把它们直接作为参数传给需要函数式接口的方法。与 [Lambdas01.java] 比较:不再需要编写方法 [isEven]。这里我们操作的是列表的副本,因为 [removeIf] 会修改它所作用的列表;
  • 第 52 行:一个 [Comparator<Integer>] 类型的 lambda,它颠倒了通常的比较:列表按降序排序。

我们来回顾一下 lambda 表达式的各种形式:

形式
示例
带类型的参数,块体
[(int a, int b) -> { return a + b; }]
不带类型的参数,表达式体
[(a, b) -> a + b]
单个不带类型的参数
[x -> x * x]
无参数
[() -> "Hello"]
匿名参数
[(_, _) -> IO.println("received")]
用 [var] 声明的参数
[(var a, var b) -> a + b]

参数要么全部带类型,要么全部不带类型:不能混用。在块体中,返回结果的 lambda 必须在每条执行路径上都有一个 [return] 语句,与方法一样。

lambda 并不完全等同于匿名类的简写。在匿名类中,[this] 指的是该匿名类的实例;而在 lambda 中,[this] 指的是包围该 lambda 的方法所属的对象。此外,匿名类会创建一个新的作用域:它可以声明与方法中某个变量同名的变量,而 lambda 做不到。最后,匿名类可以实现具有多个方法的接口,或者继承抽象类,而 lambda 不可能做到这一点。在本课程中,只要可能,我们都会使用 lambda。

7.3.2. 补充信息:目标类型与方法引用

程序 [Lambdas04.java] 定义了目标类型的概念,并介绍了四种方法引用:

// 更多关于 lambda 和方法引用

void main() throws Exception {
    // 1 - lambda 本身没有类型:由上下文决定
    // var twice = x -> x * 2;  // 被拒绝:lambda 需要目标类型
    var twice = (IntUnaryOperator) x -> x * 2;
    IO.println("twice(21)=" + twice.applyAsInt(21));
    // 同一段 lambda 文本可以实现两个不同的接口
    Supplier<String> supplier = () -> "Hello";
    Callable<String> callable = () -> "Hello";
    IO.println(supplier.get() + " / " + callable.call());

    // 2 - 用 var 声明的参数(Java 11):允许为它们添加注解或设为 final
    BinaryOperator<String> concatenate = (final var s1, final var s2) -> s1 + s2;
    IO.println(concatenate.apply("lam", "bda"));

    // 3 - 四种方法引用
    // a) 静态方法:Class::staticMethod
    Function<String, Integer> convert = Integer::parseInt;
    IO.println("convert(\"42\") + 1 = " + (convert.apply("42") + 1));
    // b) 给定对象的实例方法:object::method
    String name = "Pierre";
    Supplier<String> inUpperCase = name::toUpperCase;
    IO.println("inUpperCase.get()=" + inUpperCase.get());
    // c) 任意对象的实例方法:Class::instanceMethod
    //    调用该方法的对象成为第一个参数
    UnaryOperator<String> upperCase = String::toUpperCase;
    Comparator<String> ignoreCase = String::compareToIgnoreCase;
    IO.println("upperCase(\"paul\")=" + upperCase.apply("paul")
            + ", ignoreCase(\"abc\", \"ABC\")=" + ignoreCase.compare("abc", "ABC"));
    // d) 构造函数:Class::new
    Supplier<List<String>> createList = ArrayList::new;
    Function<String, StringBuilder> createBuffer = StringBuilder::new;
    IntFunction<int[]> createArray = int[]::new;
    List<String> list = createList.get();
    list.add("element");
    IO.println(list + " " + createBuffer.apply("abc").reverse() + " " + createArray.apply(3).length);

    // 4 - 受检异常:Callable.call 可以抛出它们,Supplier.get 不能
    Callable<Integer> read = () -> {
        throw new IOException("missing file");
    };
    try {
        read.call();
    } catch (IOException ex) {
        IO.println("exception received: " + ex.getMessage());
    }

    // 5 - 每次对 lambda 或方法引用求值都可能创建一个新对象
    Supplier<String> r1 = name::toUpperCase;
    Supplier<String> r2 = name::toUpperCase;
    IO.println("r1 == r2: " + (r1 == r2) + ", r1.equals(r2): " + r1.equals(r2));
}

结果:

> java Lambdas04.java
twice(21)=42
Hello / Hello
lambda
convert("42") + 1 = 43
inUpperCase.get()=PIERRE
upperCase("paul")=PAUL, ignoreCase("abc", "ABC")=0
[element] cba 3
exception received: missing file
r1 == r2: false, r1.equals(r2): false

说明:

  • 第 5 行:lambda 本身没有类型。它的类型由上下文决定:接收它的变量的类型、传递给的参数的类型,或者转换所指定的类型。因此,声明 [var twice = x -> x * 2;] 会被编译器拒绝:[cannot infer type for local variable twice (lambda expression needs an explicit target-type)]。它不知道该实现哪个接口;
  • 第 6 行:通过转换为 [IntUnaryOperator],目标类型已知,[var] 就变得有效了。实际上,人们会改写成 [IntUnaryOperator twice = x -> x * 2;];
  • 第 9–10 行:同一个 lambda 表达式 [() -> "Hello"],在这里实现了一个 [Supplier<String>],在那里实现了一个 [Callable<String>]。这是两个不同类的对象,它们只共享方法的形式;
  • 第 14 行:自 Java 11 起,lambda 参数可以用 [var] 声明,这样就可以为它们添加修饰符([final])或注解——这是不带类型的参数无法做到的;
  • 第 17–37 行:四种方法引用:
    • 第 19 行:对 静态方法 的引用,[Class::staticMethod]。[Integer::parseInt] 等价于 lambda [s -> Integer.parseInt(s)];
    • 第 23 行:对 给定对象 的实例方法的引用,[object::method]。[name::toUpperCase] 等价于 [() -> name.toUpperCase()]:对象 [name] 被一次性固定下来;
    • 第 27–28 行:对类的 任意对象 的实例方法的引用,[Class::instanceMethod]。调用该方法的对象尚不确定:它成为函数的 第一个参数。[String::toUpperCase] 等价于 [s -> s.toUpperCase()] (一个参数),而 [String::compareToIgnoreCase] 等价于 [(s1, s2) -> s1.compareToIgnoreCase(s2)] (两个参数),因此是 [Comparator<String>];
    • 第 32–34 行:对 构造函数 的引用,[Class::new]。[ArrayList::new] 等价于 [() -> new ArrayList<>()];[StringBuilder::new]在目标类型 为 [Function<String, StringBuilder>] 时,会选择接受字符串的构造函数;[int[]::new] 创建一个大小为所传参数的数组;
  • 第 37 行:用到了这三个创建函数;[reverse] 反转 [StringBuilder] 的内容(结果的第 8 行);
  • 第 40–47 行:[Callable] 和 [Supplier] 之间的一个重要区别。方法 [call] 被声明为 [throws Exception]:因此 [Callable] 类型的 lambda 可以抛出受检异常(见第 3 章),这里是一个 [IOException]。[get] 方法属于 [Supplier] ,它不声明任何异常:同一个 lambda 若是 [Supplier<Integer>] 类型就会被拒绝([unreported exception IOException; must be caught or declared to be thrown])。[java.util.function] 中没有任何接口允许受检异常:抛出受检异常的 lambda 必须自己捕获它,或者使用其方法声明了该异常的接口。这就是为什么 [main] 被声明为 [throws Exception] (第 3 行):对 [callable.call()] (第 11 行)和 [read.call()](第 44 行)的调用理论上可能抛出任何 [Exception],而第 45 行的 [catch] ——仅限于 [IOException]——并不会捕获它;
  • 第 50–52 行:对同一个方法引用 [name::toUpperCase] 求值两次会产生两个不同的对象,[==] 和 [equals] 都不认为它们相等(结果的第 10 行)。请记住这一点:在取消订阅事件监听器时它会很重要。

方法引用只是仅调用一个方法的 lambda 的简写记法。当它能提高可读性时我们就使用它:用 [String::length] 而不是 [s -> s.length()]。

7.3.3. 组合函数

预定义的函数式接口带有 [default] 方法和 [static] 方法,可以根据现有函数创建新函数,例如我们的 [then] 方法在 [Operation] 接口中的作用。程序 [Lambdas05.java] 列出了其中的主要方法:

// 组合函数:andThen、compose、and、or、negate、comparing、thenComparing

void main() {
    // 1 - Function:andThen(先执行自身,再执行另一个)和 compose(先执行另一个)
    Function<Integer, Integer> plusOne = x -> x + 1;
    Function<Integer, Integer> timesTwo = x -> x * 2;
    IO.println("plusOne.andThen(timesTwo).apply(5)=" + plusOne.andThen(timesTwo).apply(5));
    IO.println("plusOne.compose(timesTwo).apply(5)=" + plusOne.compose(timesTwo).apply(5));
    // 由函数列表构建的处理链
    List<UnaryOperator<String>> steps =
            List.of(String::strip, String::toLowerCase, s -> s.replace(' ', '-'));
    Function<String, String> normalize = Function.identity();
    for (UnaryOperator<String> step : steps) {
        normalize = normalize.andThen(step);
    }
    IO.println("normalize(\"  My Nice Title \")=" + normalize.apply("  My Nice Title "));

    // 2 - Predicate:and、or、negate、Predicate.not
    Predicate<String> isShort = s -> s.length() <= 4;
    Predicate<String> startsWithP = s -> s.startsWith("P");
    List<String> firstNames = List.of("Paul", "Mélanie", "Jo", "Sébastien", "Pierre");
    IO.println("short and P: " + filter(firstNames, isShort.and(startsWithP)));
    IO.println("short or P: " + filter(firstNames, isShort.or(startsWithP)));
    IO.println("not short: " + filter(firstNames, isShort.negate()));
    IO.println("not empty: " + filter(List.of("a", "", "b"), Predicate.not(String::isEmpty)));

    // 3 - Consumer:andThen 对同一个值串联两个处理
    List<String> log = new ArrayList<>();
    Consumer<String> display = s -> IO.println("display: " + s);
    Consumer<String> remember = log::add;
    Consumer<String> both = display.andThen(remember);
    both.accept("first");
    both.accept("second");
    IO.println("log: " + log);

    // 4 - Comparator:comparing、thenComparing、reversed
    List<Person> persons = new ArrayList<>(List.of(new Person("Paul", 32),
            new Person("Mélanie", 25), new Person("Jo", 32), new Person("Sébastien", 25)));
    persons.sort(Comparator.comparing(Person::age).thenComparing(Person::name));
    IO.println("by age then name: " + persons);
    persons.sort(Comparator.comparingInt(Person::age).reversed()
            .thenComparing(Person::name, Comparator.reverseOrder()));
    IO.println("by descending age then descending name: " + persons);
    // BinaryOperator.minBy 由比较器构建函数
    BinaryOperator<Person> youngest = BinaryOperator.minBy(Comparator.comparingInt(Person::age));
    IO.println("youngest(Paul, Mélanie)=" + youngest.apply(persons.get(0), persons.get(3)));
}

// 保留满足该谓词的元素
static <T> List<T> filter(List<T> elements, Predicate<? super T> predicate) {
    List<T> result = new ArrayList<>();
    for (T element : elements) {
        if (predicate.test(element)) {
            result.add(element);
        }
    }
    return result;
}

record Person(String name, int age) {
    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

结果:

> java Lambdas05.java
plusOne.andThen(timesTwo).apply(5)=12
plusOne.compose(timesTwo).apply(5)=11
normalize("  My Nice Title ")=my-nice-title
short and P: [Paul]
short or P: [Paul, Jo, Pierre]
not short: [Mélanie, Sébastien, Pierre]
not empty: [a, b]
display: first
display: second
log: [first, second]
by age then name: [Mélanie(25), Sébastien(25), Jo(32), Paul(32)]
by descending age then descending name: [Paul(32), Jo(32), Sébastien(25), Mélanie(25)]
youngest(Paul, Mélanie)=Mélanie(25)

说明:

  • 第 7 行:[f.andThen(g)] 返回先应用 [f]、再应用 [g] 的结果:(5 + 1) × 2 = 12;
  • 第 8 行:[f.compose(g)] 先应用 [g],再应用 [f]:5 × 2 + 1 = 11;
  • 第 10–15 行:动态构造的处理链。我们从恒等函数([Function.identity()],它保持参数不变)开始,并通过 [andThen] 添加列表中的每一个步骤。得到的函数 [normalize] 会去除首尾空格,把文本转换为小写,并把空格替换为短横线。每次调用 [andThen] 都会创建一个 新函数:现有函数从不被修改。同样,步骤列表也可以从配置文件中读取;
  • 第 19–25 行:使用 [and] (与)、[or] (或)和 [negate] (非)来组合谓词。静态方法 [Predicate.not] (Java 11)返回谓词的否定:它允许您写成 [Predicate.not(String::isEmpty)],而 [String::isEmpty.negate()] 会被拒绝(方法引用在拥有目标类型之前没有类型);
  • 第 28–34 行:[c1.andThen(c2)] 返回一个 [Consumer], 它对同一个值先执行 [c1] 再执行 [c2] 。这是 Java 中通过一次调用执行多个操作的最简单方式。第 30 行:[log::add] 是对 [add] 方法的引用,该方法属于 [log] 对象;
  • 第 39 行:[Comparator.comparing(f)] 构造一个比较 [f] 的值(这里是年龄)的比较器;[thenComparing] 指定出现平局时使用的次级比较标准(这里是姓名)。记录 [Person] (第 60–65 行)提供了访问器 [age()] 和 [name()];我们重新定义了它的 [toString] 方法,以缩短显示输出;
  • 第 41–42 行:[comparingInt] 避免把年龄转换为 [Integer],[reversed] 反转到目前为止得到的顺序,而 [thenComparing] 的第二种形式除了标准之外,还接受用于该标准的比较器:[Comparator.reverseOrder()],即反向的自然顺序;
  • 第 45–46 行:[BinaryOperator.minBy] 把比较器转换为返回两个参数中较小者的函数;
  • 第 50–58 行:这些测试所使用的方法 [filter] 。它的参数类型是 [Predicate<? super T>] 而不是 [Predicate<T>]:因此,在过滤 [String] 列表时,它既接受 [Predicate<String>] ,也接受 [Predicate<Object>] 或 [Predicate<CharSequence>]。这是整个 Java 库所遵循的规则:消费 [T] 的函数式参数用 [? super T] 声明,而产生它们的参数则用 [? extends T] 声明。

这些方法让您可以通过组合简单函数来编写复杂的处理流程,而无需编写任何一个类。我们将在流 API 中再次讨论它们。

7.3.4. 变量捕获与闭包

lambda 可以使用定义它的方法的局部变量。这称为 捕获 这些变量。Java 在这方面有一条重要的规则,使该语言有别于许多其他语言(C#、JavaScript、Python):被捕获的局部变量必须是“实际上的 final”(effectively final),也就是说,它在初始化之后从不被修改,无论是在方法中还是在 lambda 中。程序 [Lambdas06.java] 演示了这条规则允许和禁止的内容:

// 变量捕获和闭包

// 隐式类的字段:lambda 可以修改它
int nbCalls;

void main() {
    // 1 - lambda 可以使用包围它的局部变量……
    int threshold = 5;
    Predicate<Integer> exceeds = n -> n > threshold;
    IO.println("threshold=" + threshold + " : exceeds(7)=" + exceeds.test(7));
    // ……前提是它们实际上是 final:threshold = 10; 会被拒绝
    int otherThreshold = 10;
    Predicate<Integer> exceedsOther = n -> n > otherThreshold;
    IO.println("threshold=" + otherThreshold + " : exceeds(7)=" + exceedsOther.test(7));

    // 2 - lambda 不能修改被捕获的局部变量……
    // int total = 0; IntConsumer accumulate = n -> total += n;  // 被拒绝
    // ……但它可以修改它所引用的对象
    AtomicInteger total = new AtomicInteger();
    IntConsumer accumulate = n -> total.addAndGet(n);
    accumulate.accept(3);
    accumulate.accept(4);
    IO.println("total=" + total.get());
    // ……或当前对象的字段(lambda 捕获 this)
    Runnable count = () -> nbCalls++;
    count.run();
    count.run();
    IO.println("nbCalls=" + nbCalls);

    // 3 - 闭包:被捕获的对象比创建它的方法存活得更久
    IntSupplier counterA = createCounter();
    IntSupplier counterB = createCounter();
    IO.println("A : " + counterA.getAsInt() + " " + counterA.getAsInt() + " " + counterA.getAsInt());
    IO.println("B : " + counterB.getAsInt() + " " + counterB.getAsInt());

    // 4 - for 循环:变量 i 会变化,无法被捕获
    List<Runnable> actions = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        // actions.add(() -> IO.print(i + " "));  // 被拒绝:i 不是实际上的 final
        int copy = i;
        actions.add(() -> IO.print(copy + " "));
    }
    IO.print("for, capture of a copy: ");
    actions.forEach(Runnable::run);
    IO.println();

    // for-each 循环在每次迭代时声明一个新变量:它实际上是 final
    actions.clear();
    for (int j : new int[] { 0, 1, 2 }) {
        actions.add(() -> IO.print(j + " "));
    }
    IO.print("for-each: ");
    actions.forEach(Runnable::run);
    IO.println();
}

// 返回函数的方法
static IntSupplier createCounter() {
    // 被返回的 lambda 捕获的局部对象
    AtomicInteger value = new AtomicInteger();
    return () -> value.incrementAndGet();
}

结果:

1
2
3
4
5
6
7
8
9
> java Lambdas06.java
threshold=5 : exceeds(7)=true
threshold=10 : exceeds(7)=false
total=7
nbCalls=2
A : 1 2 3
B : 1 2
for, capture of a copy: 0 1 2 
for-each: 0 1 2 

说明:

  • 第 9 行:lambda 使用第 8 行声明的局部变量 [threshold] 。[threshold] 不是 lambda 的参数;它是被捕获的变量。该变量从不被修改:它实际上是 final 的,无需声明为 [final] (对于匿名类,直到 Java 7 都要求这样做);
  • 第 11 行:如果我们在创建 lambda 之后添加 [threshold = 10;] ,编译器会拒绝第 9 行的 lambda:*[local variables referenced from a lambda expression must be final or effectively final]。要改变阈值,我们需要创建另一个变量和另一个 lambda(第 12–13 行)。反过来,“lambda 看到的是变量在创建时的值,还是在执行时的值?”这个问题在 Java 中并不存在:两者是相同的。具体来说,lambda 在创建时会收到变量值的一份 副本* ;
  • 第 17 行:出于同样的原因,lambda 不能修改被捕获的局部变量:[n -> total += n] 会被拒绝,错误消息相同;
  • 第 19–23 行:被捕获的变量 [total] 不变;它仍然引用同一个对象 [AtomicInteger]。然而,没有什么能阻止 lambda 修改该对象的 状态 。包 [AtomicInteger] 中的类 [java.util.concurrent.atomic] 封装了一个可变整数([addAndGet]、[incrementAndGet]、[get]……),多个线程可以安全地使用它(第 8 章)。我们还会遇到单元素数组的技巧([int[] total = {0};] 之后是 [total[0] += n]),它不具备后一种特性;
  • 第 4 行和第 25–28 行:该规则只适用于 局部变量。lambda 可以读取和修改当前对象的字段:此时它捕获的是引用 [this],而该引用本身不会改变。字段 [nbCalls] 是紧凑源文件的隐式类的字段;由于方法 [main] 是实例方法,lambda 可以对它进行递增;
  • 第 58–62 行:方法 *[createCounter] 返回一个捕获了其局部变量 *[value]* 的 lambda。通常,局部变量会在方法结束时销毁。而在这里,返回的 lambda 保留了引用 [value] 的一份副本,只要该 lambda 存在,被引用的对象 [AtomicInteger] 就会在 [createCounter]* 结束后继续存活。lambda 与它所捕获的值的组合称为“闭包”。为了创建它,虚拟机会把被捕获的值存储在它为该 lambda 创建的对象的字段中;
  • 第 31–34 行:每次调用 [createCounter] 都会创建一个新的 [AtomicInteger] 对象——也就是一个新的计数器——它独立于其他计数器。结果(第 6–7 行)证实了这一点;
  • 第 38–42 行:在标准的 [for] 循环中,变量 [i] 在每次迭代中都会被修改([i++]):它不是实际上的 final,因此第 39 行的 lambda 会被拒绝。在其他语言中,这种捕获是允许的,并会导致出人意料的结果:三个 lambda 共享同一个变量 [i] ,并且都会打印 3,即循环结束时它的值。Java 在编译时就消除了这个陷阱。解决办法是在循环体内声明一个变量 [copy]——每次迭代都是一个从不被修改的新变量(第 40 行)——这样每个 lambda 都捕获它自己的变量;
  • 第 49–51 行:使用“针对每个元素”的循环 [for],就不会出现这个问题:变量 [j] 在每次迭代中都是一个新变量,从不被修改,因此是实际上的 final;
  • 第 44 行和第 53 行:集合的 [forEach] 方法需要一个 [Consumer] 并对每个元素执行它。这里,每个元素本身就是一个 *[Runnable]*,引用 **[Runnable::run]***(任何 *[Runnable]* 类型的对象,对它调用 *[run] )会执行它。

关于实际上的 final 变量的规则可能显得有些严格。然而,它有充分的理由:lambda 可能稍后才被执行,或者在另一个线程中执行(第 8 章)。如果它能够修改可能早已结束的方法的局部变量,或者在另一个线程正在修改这些变量时读取它们,我们就会遇到难以预测的行为。通过要求变量保持不变,Java 避免了这些情形;当确实需要共享的可变状态时,就通过一个对象([AtomicInteger]、集合等)显式地表达出来,该对象在线程方面的行为是有明确规定的。

7.4. 函数式接口还是接口?

在许多语言中,“作为参数传递的函数”这一概念(C 中的函数指针、C# 中的委托)与接口的概念是不同的,人们可能会想该选择哪一个。在 Java 中,这个问题的提法有所不同,因为这两个概念其实是同一回事:lambda 就是 接口的一个实例。让我们看示例 [Lambdas07.java],它与 [Lambdas02.java] 类似:

// 函数式接口类型的参数

void main() {
    // 执行 add 方法
    IO.println(execute(Methods::add, 2, 3));
    // 执行 subtract 方法
    IO.println(execute(Methods::subtract, 2, 3));
    // 执行具有合适形式的 Java 库方法
    IO.println(execute(Math::max, 2, 3));
    // 执行 lambda:不需要具名方法
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
}

// 执行作为参数接收的操作
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// 两个具有 Operation 接口形式的方法
class Methods {
    static int add(int n1, int n2) {
        IO.println("add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }

    static int subtract(int n1, int n2) {
        IO.println("subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }
}

// 函数式接口
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);
}

结果:

1
2
3
4
5
6
7
> java Lambdas07.java
add(2,3)
5
subtract(2,3)
-1
3
6

在第 15 行,方法 *[execute] 需要一个由第 34 行的函数式接口 *[Operation] 所定义类型的参数。这使我们可以向它传递不同的函数:我们的类 [Methods] 中的静态方法(第 5 行和第 7 行)、Java 库中形式正确的方法(第 9 行:在 *[Math.max]* 的各个重载中,编译器选择 ***[int max(int a, int b)]*),甚至是 lambda(第 11 行):无需编写乘法方法。这种多态是第 4 章介绍的接口的多态:程序 [Lambdas08.java] 通过用类实现同一个接口来演示这一点:

// 实现该函数式接口的类

void main() {
    // 执行 Add 操作
    IO.println(execute(new Add(), 2, 3));
    // 执行 Subtract 操作
    IO.println(execute(new Subtract(), 2, 3));
    // 同一个 execute 方法仍然接受 lambda
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
    // 有两个抽象方法的接口不再接受 lambda:需要一个类
    NamedOperation division = new NamedOperation() {
        @Override
        public int calculate(int n1, int n2) {
            return n1 / n2;
        }

        @Override
        public String name() {
            return "integer division";
        }
    };
    IO.println(division.name() + " : " + division.calculate(7, 2));
}

// 执行 Operation 接口的唯一方法
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// 接口 Operation
interface Operation {
    int calculate(int n1, int n2);
}

// 非函数式接口:有两个抽象方法
interface NamedOperation extends Operation {
    String name();
}

// 类 Add
class Add implements Operation {
    @Override
    public int calculate(int n1, int n2) {
        IO.println("Add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }
}

// 类 Subtract
class Subtract implements Operation {
    @Override
    public int calculate(int n1, int n2) {
        IO.println("Subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }
}

结果:

1
2
3
4
5
6
7
> java Lambdas08.java
Add(2,3)
5
Subtract(2,3)
-1
6
integer division : 3

说明:

  • 第 31–33 行:[Operation] 接口定义了一个方法 [calculate]。它没有带注解 [@FunctionalInterface]:该注解只是一种检查,任何只有一个抽象方法的接口都是函数式接口;
  • 第 41–47 行和第 50–56 行:类 *[Add] 和 *[Subtract] 实现接口 *[Operation]*;
  • 第 26–28 行:方法 [execute],其第一个参数的类型是接口 [Operation]。它依次接收一个 [Add] 类的实例、一个 [Subtract] 类的实例(第 5 行和第 7 行),然后是一个 lambda(第 9 行)。对于 [execute] 来说,这三个对象的类型相同:都是实现了 [Operation] 的对象;
  • 第 36–38 行:[NamedOperation] 接口继承了 [calculate] 方法,并添加了一个 [name] 方法。有了两个抽象方法,它就不再是函数式接口了:不能再用 lambda 来实现它;必须使用类——在这里是匿名类(第 11–21 行)。

这两个示例表明,在 Java 中,您不必在两种机制之间做选择:需要单方法接口的方法,既接受为此专门编写的类的对象,也接受方法引用和 lambda,一视同仁。因此,真正的问题是:接口应该是只有一个方法的函数式接口,还是应该有多个方法?

  • 单方法接口——无论是预定义的([Function]、[Predicate]……)还是自定义的——使用起来更加灵活:任何形式正确的现有方法都可以,lambda 甚至允许您在调用处直接编写函数。无需编写类。这种灵活性解释了为什么 现代库(流 API、第 9 章的异步编程、Spring)大量使用函数式接口;
  • 一旦要实现的行为涉及若干相互关联的操作(上面的 [calculate] 和 [name] ),或者需要自己的状态和标识,多方法接口就重新占据优势。

第 6 章中 [ITaxDao] 接口在 [dao] 层的情形就是这样:尽管它只有一个方法 [List<TaxBracket> getTaxBrackets()],但它的实现带有状态(读取的税率档、文件名),由依赖注入容器创建,并在应用程序中代表一个命名明确的角色。从技术上讲,[Supplier<List<TaxBracket>>] 就足够了,但它的描述性要差得多。因此,我们把函数式接口留给简短的一次性行为(一个标准、一次转换、一个动作),而把“业务”接口留给应用程序的角色,无论它们包含多少个方法。

7.5. 事件处理

7.5.1. 监听器模型

函数式接口用于建立事件机制。Java 没有专门用于事件的关键字:它使用一组约定,称为“监听器模型”,早在 Java 1.1 中就为图形组件和 JavaBeans 确立了。类 [C1] 想要发出事件 [Xxx] 时,按如下方式进行:

  • 一个 [XxxEvent] 类,派生自 [java.util.EventObject],封装事件信息。[EventObject] 存储触发事件的对象——称为 源——可通过 [getSource()] 获得;
  • 一个接口 [XxxListener],它扩展空接口 [java.util.EventListener] (一个简单的标记),定义事件发生时将被调用的方法。如果只有一个方法,它就是函数式接口:监听器可以是 lambda;
  • [C1] 类管理一个监听器列表,并提供两个公共方法用于订阅和取消订阅:[addXxxListener(XxxListener l)] 和 [removeXxxListener(XxxListener l)];
  • 当 [c1] 实例(属于 [C1] )想要发出事件时,它会创建一个 [XxxEvent] 对象,并调用每个已注册监听器的方法,把该对象传给它。按照约定,这种通知由一个受保护的方法 [fireXxx(XxxEvent e)] (“fire”,触发)负责处理,派生类可以重写它来修改事件的发布方式;
  • 如果 [c2] 对象想要获知 [Xxx] 事件,该事件来自 [c1] 对象,它就使用 [c1.addXxxListener(...)] 注册自己。当它不再希望收到通知时,可以通过 [c1.removeXxxListener(...)] 取消订阅。由于 [c1] 管理的是一个列表,不同的对象可以订阅以获知同一个事件。

在这种情形中,我们有:

  • 一个发出(也称为“发布”或“发射”)事件的类;
  • 获知该事件的对象。它们被称为订阅或注册该事件:这些就是监听器,即事件处理程序;
  • 一个监听器接口,它定义将被通知该事件的方法的签名。

这就是 观察者 设计模式:发射器并不了解它的订阅者;它只是通知它们。这种模型提供的保护与专用关键字相同:监听器列表是发射器的私有字段。从外部只能订阅或取消订阅;不能清空列表、替换其他监听器,也不能代替发射器触发事件。

7.5.2. 示例:温度过高

考虑下面的示例:

  • 一个名为 [Emitter] 的类封装了一个温度。当该温度超过某个阈值时,必须触发一个事件。我们把这个事件称为 [TemperatureTooHigh]。关于该事件的信息将封装在一个 [TemperatureTooHighEvent] 对象中,监听器将实现 [TemperatureTooHighListener] 接口;
  • 一个名为 [Subscriber] 的类注册为上述事件的监听器。当它收到事件通知时,会在控制台上显示一条消息。订阅者在收到指定数量的警报后会自动取消订阅;
  • 一个控制台程序创建一个发布者和两个订阅者。它通过键盘输入温度,并把它们存储在发布者中。如果其中任何一个温度过高,发布者就会发出 [TemperatureTooHigh] 事件。

所有这些类都集中在紧凑源文件 [Lambdas09.java] 中,我们分三部分展示它。首先是事件类、监听器接口和类 [Emitter]:

// 事件携带的信息
class TemperatureTooHighEvent extends EventObject {
    @Serial
    private static final long serialVersionUID = 1L;
    // 事件发生时的温度
    private final double temperature;
    // 事件发生的时间
    private final LocalTime time = LocalTime.now();

    TemperatureTooHighEvent(Emitter source, double temperature) {
        super(source);
        this.temperature = temperature;
    }

    // 事件源必然是 Emitter:我们用更精确的类型重写 getSource
    @Override
    public Emitter getSource() {
        return (Emitter) super.getSource();
    }

    double getTemperature() {
        return temperature;
    }

    LocalTime getTime() {
        return time;
    }
}

// 事件监听器必须实现的接口
@FunctionalInterface
interface TemperatureTooHighListener extends EventListener {
    void temperatureTooHigh(TemperatureTooHighEvent e);
}

// 发出事件信号的类
class Emitter {
    // 触发事件的阈值
    static final double THRESHOLD = 19;
    // 发射器的名称
    private final String name;
    // 观测到的温度
    private double temperature;
    // 已注册的监听器
    private final List<TemperatureTooHighListener> listeners = new CopyOnWriteArrayList<>();

    Emitter(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    double getTemperature() {
        return temperature;
    }

    void setTemperature(double temperature) {
        this.temperature = temperature;
        if (temperature > THRESHOLD) {
            // 我们向监听器发出事件信号
            fireTemperatureTooHigh(new TemperatureTooHighEvent(this, temperature));
        }
    }

    // 注册监听器
    void addTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.add(Objects.requireNonNull(listener));
    }

    // 注销监听器
    void removeTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.remove(listener);
    }

    // 向所有已注册的监听器通知事件
    protected void fireTemperatureTooHigh(TemperatureTooHighEvent e) {
        for (TemperatureTooHighListener listener : listeners) {
            listener.temperatureTooHigh(e);
        }
    }
}

说明:

  • 第 1–28 行:类 [TemperatureTooHighEvent] 按照约定派生自 [EventObject]。它的构造函数(第 10–13 行)把事件源传给 [EventObject] 的构造函数([super(source)]),并存储触发事件的温度。我们增加了事件时间 [time] (第 8 行)。字段是 [final] 的,并且该类只有只读的访问器:监听器不得修改事件信息,以免影响后续的监听器;
  • 第 3–4 行:[EventObject] 实现了 [Serializable] 接口(以便事件可以被记录或通过网络传输)。使用 [-Xlint:all] 选项时,编译器随后要求每个派生类声明一个版本号 [serialVersionUID]。[@Serial] 注解(Java 14)向编译器标明这个特定的字段;
  • 第 16–19 行:[getSource] 方法在 [EventObject] 中返回一个 [Object]。我们用更具体的返回类型 [Emitter] 重新定义它,Java 允许这样做(协变返回类型):监听器无需对事件源进行强制转换。这里我们不能使用 *[record]* :记录不能继承任何类,因此也就不能继承 *[EventObject]*;
  • 第 30–34 行:监听器接口。它扩展 [EventListener] 并声明了唯一的方法 [temperatureTooHigh],该方法接收事件对象:这是一个函数式接口;
  • 第 39 行:温度阈值,超过它就触发 [TemperatureTooHigh] 事件;
  • 第 41 行:发射器有一个用于标识的名称;
  • 第 45 行:已注册监听器的列表。这是一个 [CopyOnWriteArrayList] ,来自 [java.util.concurrent] 包,这种列表每当被修改时,都会把内容复制到一个新数组中。因此,正在进行的迭代会在旧数组上继续,即使在此期间列表被修改。稍后我们会看到为什么这在这里至关重要。这种列表是监听器列表的标准类型:每个事件都要遍历列表,但很少修改它;
  • 第 59–65 行:方法 [setTemperature] 记录新的温度,如果它超过阈值就发出事件;
  • 第 63 行:发布由 [fireTemperatureTooHigh] 方法处理,向它传递一个 [TemperatureTooHighEvent] 对象;该对象来自发射器自身([this]),并包含超过阈值的温度;
  • 第 68–70 行:注册监听器就是把它添加到列表中。[Objects.requireNonNull] 会立即拒绝 [null] 监听器,否则它会在很久以后的通知过程中触发 [NullPointerException] ;
  • 第 73–75 行:注销就是把监听器从列表中移除。方法 [remove] 使用 [equals] 查找要移除的对象;因此,必须向它传递 当初注册的那同一个对象;
  • 第 78–82 行:通知会按照监听器注册的顺序,对每个已注册的监听器调用 [temperatureTooHigh] 方法。如果没有监听器,循环什么也不做:无需处理特殊情况。

下面是 [Subscriber] 类:

// 注册为该事件监听器的类
class Subscriber {
    // 订阅者的名称
    private final String name;
    // 可接受的最大警报数
    private final int nbAlertsMax;
    // 已收到的警报数
    private int nbAlerts;
    // 监听器只创建一次,以便之后可以注销
    private final TemperatureTooHighListener listener = this::evtTemperatureTooHigh;

    Subscriber(String name, int nbAlertsMax) {
        this.name = name;
        this.nbAlertsMax = nbAlertsMax;
    }

    // 向发射器注册
    void subscribe(Emitter emitter) {
        emitter.addTemperatureTooHighListener(listener);
    }

    // 注销
    void unsubscribe(Emitter emitter) {
        emitter.removeTemperatureTooHighListener(listener);
    }

    // TemperatureTooHigh 事件的处理程序
    private void evtTemperatureTooHigh(TemperatureTooHighEvent e) {
        Emitter emitter = e.getSource();
        IO.println("Subscriber [%s]: the source [%s] reported a temperature too high: [%.1f]"
                .formatted(name, emitter.getName(), e.getTemperature()));
        // 超过 nbAlertsMax 个警报后,订阅者取消订阅
        nbAlerts++;
        if (nbAlerts == nbAlertsMax) {
            unsubscribe(emitter);
            IO.println("Subscriber [%s]: unsubscribed after %d alert(s)".formatted(name, nbAlerts));
        }
    }
}

说明:

  • 第 4–6 行:每个订阅者由一个名称标识,并被分配其接受的最大警报数([nbAlertsMax]);
  • 第 10 行:订阅者的监听器是对其私有方法 [evtTemperatureTooHigh] 的引用。我们在 [Lambdas04.java] 中看到,对 [this::evtTemperatureTooHigh] 求值两次会产生两个不同的对象。如果我们在 [emitter.addTemperatureTooHighListener(this::evtTemperatureTooHigh)] 中写入 [subscribe] ,然后在 [emitter.removeTemperatureTooHighListener(this::evtTemperatureTooHigh)] 中写入 [unsubscribe],那么取消订阅将不会移除任何东西,而且不会显示任何错误消息!因此,我们只创建一次监听器,并把它存储在字段中;
  • 第 18–20 行:订阅发布者。这是订阅者的职责;订阅者知道取消订阅时要移除哪个对象;
  • 第 23–25 行:取消订阅移除的是同一个对象 [listener]。每个订阅者都有自己的对象 [listener]:[remove] 只移除属于相关订阅者的那一个;
  • 第 28 行:事件处理程序。它具有 [TemperatureTooHighListener] 接口所规定的形式。它是私有的:只有订阅者才能把它注册到发布者。另一种非常常见的做法是让 [Subscriber] 类本身([class Subscriber implements TemperatureTooHighListener])实现监听器接口,并用 [this] 注册。这种做法的缺点是使 [temperatureTooHigh] 方法成为公共方法,任何人都可以调用它;
  • 第 29 行:由于重新定义了 [getSource],事件源直接就是 [Emitter] 类型;
  • 第 30–31 行:处理程序显示订阅者的名称、报告该事件的发射器的名称,以及触发它的温度。[%.1f] 格式把实数显示为一位小数,这里使用小数点;
  • 第 33–37 行:在收到 [nbAlertsMax] 次警报后,订阅者向发布者取消订阅。订阅者是 在 事件通知期间从它自己的处理程序中这样做的——也就是在 [fireTemperatureTooHigh] 方法正在遍历监听器列表的时候。多亏了 [CopyOnWriteArrayList],这样做是安全的:[remove] 会创建一个新数组,但当前的迭代仍在旧数组上继续。

最后是主程序:

// 事件处理:一个发射器和若干监听器

void main() {
    // 创建事件发射器
    var e1 = new Emitter("e");
    // 创建两个向 e1 注册的订阅者
    List<Subscriber> subscribers = List.of(new Subscriber("s0", 3), new Subscriber("s1", 1));
    for (Subscriber subscriber : subscribers) {
        subscriber.subscribe(e1);
    }
    // 第三个监听器:一个 lambda 表达式
    e1.addTemperatureTooHighListener(
            e -> IO.println("Log: %.1f °C at %tT".formatted(e.getTemperature(), e.getTime())));

    // 我们从键盘读取温度
    while (true) {
        String input = IO.readln("Temperature (nothing to stop): ");
        // 输入结束?(如果标准输入已关闭,readln 返回 null)
        if (input == null || input.isBlank()) {
            break;
        }
        try {
            // 我们接受小数逗号
            double temperature = Double.parseDouble(input.strip().replace(',', '.'));
            // 温度正确,将其记录到发射器中
            e1.setTemperature(temperature);
        } catch (NumberFormatException ex) {
            // 我们报告错误
            IO.println("Incorrect temperature");
        }
    }
}

结果:

> java Lambdas09.java
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] reported a temperature too high: [21.0]
Subscriber [s1]: the source [e] reported a temperature too high: [21.0]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21.0 °C at 18:58:41
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22,5
Subscriber [s0]: the source [e] reported a temperature too high: [22.5]
Log: 22.5 °C at 18:58:41
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] reported a temperature too high: [25.0]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25.0 °C at 18:58:41
Temperature (nothing to stop): 30
Log: 30.0 °C at 18:58:41
Temperature (nothing to stop): 

说明:

  • 第 5 行:创建发射器;
  • 第 7–10 行:创建两个订阅者 [s0] (最多 3 次警报)和 [s1] (1 次警报),它们被注册到发射器;
  • 第 12–13 行:第三个监听器,一个 lambda,充当日志。参数 [e] 的类型根据参数 [addTemperatureTooHighListener] 的类型推断得出。格式 [%tT] 把时间显示为 [HH:mm:ss] 的形式。这个 lambda 无法被注销:必须事先把它存储在变量中,才能把它传给 [removeTemperatureTooHighListener]。因此,直接写在注册调用中的 lambda 仅用于那些在发射器存在期间一直保持注册的监听器;
  • 第 16–31 行:通过键盘输入温度的循环。[IO.readln(prompt)] 显示提示并读取一行;如果标准输入已关闭,它返回 [null] ,这被视为空输入(第 19 行);
  • 第 24 行:[Double.parseDouble] 只接受小数点。为了让法国用户可以输入 [22,5],逗号被替换为句点。如果输入的不是数字,[parseDouble] 会触发 [NumberFormatException],它在第 27 行被捕获;
  • 第 26 行:如果输入的温度有效,就把它传给发射器 [e1],如果温度高于 19 °C,发射器就会发出 [TemperatureTooHigh] 事件。

结果显示如下(标准输入由文件提供,这就是所有时间都相同的原因):

  • 第 2 行:17 °C 没有超过阈值:没有事件;
  • 第 3–7 行:21 °C 触发了事件。三个监听器按照它们注册的顺序收到通知。只接受一次警报的 [s1] 立即取消订阅,但这并不妨碍在它之后注册的日志收到通知;
  • 第 10–12 行:[s1] 不再收到通知;
  • 第 13–16 行:[s0] 收到它的第三次警报,随后也取消订阅;
  • 第 18 行:只剩下日志。

如果第一段代码第 45 行只是一个 [ArrayList] (在 [Emitter] 类中),会发生什么?我们测试过:当 [s1] 在列表正被处理时取消订阅,后续的元素会被跳过,处理立即停止。日志收不到温度 21 和 25 的通知,而且没有任何错误消息。在其他配置下,迭代会触发 [ConcurrentModificationException]。因此,监听器列表必须始终支持在迭代期间被修改:[CopyOnWriteArrayList] 正是为此而设计的,它还支持其他线程进行的订阅和取消订阅(第 8 章)。

7.5.3. 属性变更事件

最常见的事件类型发生在对象的属性值改变时:另一个对象(图形用户界面、缓存、日志)希望获知这一变更。Java 库为此提供了一个现成的类 [java.beans.PropertyChangeSupport],它替我们管理监听器列表。监听器实现函数式接口 [PropertyChangeListener],其方法 [void propertyChange(PropertyChangeEvent evt)] 接收一个包含事件源、属性名及其旧值和新值的事件。程序 [Lambdas10.java] 使用了它:

// 属性变更事件:java.beans.PropertyChangeSupport

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

void main() {
    var thermometer = new Thermometer("living room");
    // 监听所有属性的监听器
    PropertyChangeListener log = e -> IO.println("Log: %s.%s : %s -> %s".formatted(
            ((Thermometer) e.getSource()).getName(), e.getPropertyName(), e.getOldValue(), e.getNewValue()));
    thermometer.addPropertyChangeListener(log);
    // 仅监听 temperature 属性的监听器
    thermometer.addPropertyChangeListener("temperature", e -> {
        if ((double) e.getNewValue() > 19) {
            IO.println("Alert: temperature too high");
        }
    });

    thermometer.setTemperature(18);
    thermometer.setTemperature(21.5);
    // 值相同:不触发事件
    thermometer.setTemperature(21.5);
    thermometer.setName("lounge");
    // 注销日志监听器
    thermometer.removePropertyChangeListener(log);
    thermometer.setTemperature(22);
    IO.println("remaining listeners: " + thermometer.getNbListeners());
}

// 属性变化时会发出信号的类
class Thermometer {
    // 监听器的管理委托给 PropertyChangeSupport 对象
    private final PropertyChangeSupport changes = new PropertyChangeSupport(this);
    private String name;
    private double temperature;

    Thermometer(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    void setName(String name) {
        String old = this.name;
        this.name = name;
        changes.firePropertyChange("name", old, name);
    }

    double getTemperature() {
        return temperature;
    }

    void setTemperature(double temperature) {
        double old = this.temperature;
        this.temperature = temperature;
        changes.firePropertyChange("temperature", old, temperature);
    }

    // 监听器的注册与注销
    void addPropertyChangeListener(PropertyChangeListener listener) {
        changes.addPropertyChangeListener(listener);
    }

    void addPropertyChangeListener(String property, PropertyChangeListener listener) {
        changes.addPropertyChangeListener(property, listener);
    }

    void removePropertyChangeListener(PropertyChangeListener listener) {
        changes.removePropertyChangeListener(listener);
    }

    int getNbListeners() {
        return changes.getPropertyChangeListeners().length;
    }
}

结果:

1
2
3
4
5
6
7
> java Lambdas10.java
Log: living room.temperature : 0.0 -> 18.0
Log: living room.temperature : 18.0 -> 21.5
Alert: temperature too high
Log: lounge.name : living room -> lounge
Alert: temperature too high
remaining listeners: 1

说明:

  • 第 3–4 行:包 [java.beans] 属于模块 [java.desktop],而不属于模块 [java.base]:即使在紧凑源文件中,也必须显式导入它;
  • 第 33 行:类 [Thermometer] 把对其监听器的管理委托给一个 [PropertyChangeSupport] 对象,该对象由事件源([this])构造。第 62–72 行的方法只是把订阅和取消订阅请求传递给它;
  • 第 45–49 行和第 55–59 行:每个修改器都会保存旧值、记录新值,并使用属性名和两个值调用 [firePropertyChange] 。仅当两个值不同时,[firePropertyChange] 才会通知监听器:因此第 22 行没有产生任何输出;
  • 第 9–11 行:第一个监听器,一个存储在变量中的 lambda,以便可以取消订阅(第 25 行)。它订阅了对象的所有属性。[e.getSource()] 返回一个 [Object],必须对其进行强制转换。这些值都是对象:[double] 对象 已被转换为 [Double],其 [toString] 方法使用小数点;
  • 第 13–17 行:第二个传感器,仅为 [temperature] 属性注册。当温度超过 19 °C 时,它会触发警报;
  • 第 19–26 行:属性变更。名称的变更(第 23 行)只报告给日志。在结果的第 5 行,日志显示了事件源的新名称 [lounge]:事件是在变更之后报告的;
  • 第 26–27 行:向日志取消订阅之后,只显示警报,并且只剩下一个监听器。

因此,无需编写事件类或监听器接口,我们就得到了一套完整的机制。这就是 Swing GUI 组件和 JavaBeans 所使用的机制;JavaFX 有它自己的、非常相似的基于可观察属性的机制。

7.6. Lambda 与流 API

在第 5 章中,我们通过向流 API 的方法([filter]、[map]、[sorted]……)传递 lambda 表达式来使用它们。现在我们知道了这些参数是什么:[filter] 方法在 [java.util.stream.Stream<T>] 接口中是这样声明的:[Stream<T> filter(Predicate<? super T> predicate)]。

它的参数是一个 [Predicate]:任何接受一个元素并返回布尔值的方法或 lambda 都可以。类似地,[map] 需要一个 [Function<? super T, ? extends R>],[sorted] 需要 一个 [Comparator],[forEach] 需要 一个 [Consumer],[reduce] 需要 一个 [BinaryOperator]……为了充分理解流 API 的工作原理,让我们编写自己的过滤和转换操作。这就是程序 [Lambdas11.java]:

// lambda 表达式与 Stream API

void main() {
    List<Integer> numbers = List.of(3, 8, 1, 6, 5, 4, 9, 2);

    // 1 - filter 和 map 分别需要 Predicate<T> 和 Function<T, R>
    Predicate<Integer> isEven = n -> n % 2 == 0;
    Function<Integer, Integer> square = n -> n * n;
    List<Integer> evenSquares = numbers.stream().filter(isEven).map(square).toList();
    IO.println("Stream: " + evenSquares);

    // 2 - 我们自己的过滤方法,先用 lambda 表达式调用,再用方法引用调用
    IO.println("filter(n > 4): " + Tools.filter(numbers, n -> n > 4));
    IO.println("filter(isOdd): " + Tools.filter(numbers, Tools::isOdd));

    // 3 - 延迟执行:谓词只有在终端操作时才会被调用
    Stream<Integer> large = numbers.stream().filter(n -> {
        IO.print("[test " + n + "] ");
        return n > 7;
    });
    IO.println("the stream is defined, nothing has been executed yet");
    large.forEach(n -> IO.print("-> " + n + " "));
    IO.println();

    // 4 - 使用 gatherer 的自定义中间操作(Gatherer,Java 24)
    List<String> cities = List.of("Angers", "Paris", "Lyon", "Nantes", "Aix");
    List<String> result = cities.stream()
            .gather(Tools.filter(v -> v.length() <= 5))
            .gather(Tools.transform(String::toUpperCase))
            .toList();
    IO.println("gatherers: " + result);
}

class Tools {
    // 用谓词过滤列表:filter 所做的工作
    static <T> List<T> filter(List<T> source, Predicate<? super T> predicate) {
        List<T> result = new ArrayList<>();
        for (T element : source) {
            if (predicate.test(element)) {
                result.add(element);
            }
        }
        return result;
    }

    static boolean isOdd(int n) {
        return n % 2 != 0;
    }

    // 一个中间流操作,只放行满足谓词的元素
    static <T> Gatherer<T, ?, T> filter(Predicate<? super T> predicate) {
        return Gatherer.of((_, element, downstream) -> !predicate.test(element) || downstream.push(element));
    }

    // 一个转换每个元素的中间操作:相当于 map
    static <T, R> Gatherer<T, ?, R> transform(Function<? super T, ? extends R> transformation) {
        return Gatherer.of((_, element, downstream) -> downstream.push(transformation.apply(element)));
    }
}

结果:

1
2
3
4
5
6
7
> java Lambdas11.java
Stream: [64, 36, 16, 4]
filter(n > 4): [8, 6, 5, 9]
filter(isOdd): [3, 1, 5, 9]
the stream is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2] 
gatherers: [PARIS, LYON, AIX]

说明:

  • 第 7–9 行:[filter] 的 lambda 首先被存储在 [Predicate<Integer>] 类型的变量中,以显示它的类型。接着,[map] 接收一个转换每个元素的 [Function<Integer, Integer>] :由此得到偶数的平方;
  • 第 36–44 行:我们自己的方法 [filter]。它是泛型的:它使用类型为 [T] 的谓词 [Predicate<? super T>] 来过滤任意类型元素的列表。它遍历列表,对每个元素调用谓词(第 39 行),并返回被选中的元素列表;
  • 第 13 行:使用 lambda 调用 [filter] 。类型 [T] 由列表推断得出:[Integer]。第 14 行:向它传递一个方法引用:[isOdd] (第 46 行)接收一个 [int];编译器会添加从 [Integer] 的转换;
  • 第 17–20 行:一个冗长的谓词,它会显示自己测试的每个元素。结果(第 5–6 行)表明,定义流并不会执行任何操作:第 21 行的消息在第一次测试之前就显示了。只有当终端操作 [forEach] (第 22 行)请求元素时,谓词才会执行,并且测试与来自 [forEach] 的显示交替进行:每个元素都先通过整个流水线,下一个元素才进入。这就是流的 延迟 (或惰性)执行。而我们的方法 [filter] 则是在返回之前就构造出整个结果列表;
  • 第 51–58 行:为了编写我们自己的中间操作——它们像流 API 中的那些一样是惰性的——我们使用 中间收集器([Gatherer],Java 24),它们是 [Collector] 收集器(由 [collect] 使用)在中间操作方面的对应物。[Gatherer.of] 接收一个带有三个参数的 lambda,对流中的每个元素调用它:一个状态(这里不需要,因此使用匿名参数 [_])、元素本身,以及流水线中的下一个阶段([downstream]),通过 [downstream.push(...)] 向它传递一个元素。lambda 返回 [false] 以停止流;我们的函数从不自行做出这种决定:它们返回 [push] 的结果,只有当下游组件不再需要任何元素时,该结果才等于 [false](或者在过滤器丢弃某个元素时为 [true] )。过滤器(第 52 行)只传递满足谓词的元素;转换(第 57 行)传递对每个元素应用函数后的结果;
  • 第 56 行:[transform] 具有双重泛型:[T] 是接收元素的类型,[R] 是产生元素的类型。参数 [Function<? super T, ? extends R>] 遵循我们已经遇到过的规则:函数消费 [T] 并产生 [R];
  • 第 27–30 行:流的 [gather] 方法把我们的操作插入链中,写法与流 API 的操作相同:我们保留最多 5 个字母的城市,然后把它们首字母大写。

整个流 API 都建立在这种模型之上:操作接收函数式接口并产生新的流,流的元素只有在终端操作提出请求时才会被计算。

7.7. 表达式树

一些语言(如 C#)允许把 lambda 转换为数据结构而不是可执行代码,该数据结构描述了这个 lambda(即“表达式树”):这样程序就可以解析 lambda [t -> t.getLimit() > 20000] ,并把它翻译成,例如,由数据库服务器执行的 SQL 子句 [WHERE limits > 20000] 。

Java 没有等价的机制。Java 的 lambda 总是被编译成可执行代码:您可以调用它,但无法检查它做了什么。因此,数据库访问库使用其他方式来表达查询。我们将在第 11 章介绍的 Hibernate 提供了两种解决方案:一种是类似于 SQL 但以类和属性来表达的查询语言,HQL (["from Bracket t where t.limit > 20000"]),以及 Jakarta Persistence 的 Criteria API,它通过方法调用来构造查询([cb.gt(t.get("limit"), 20000)])。在这两种情况下,查询都是数据(字符串或对象树),由 Hibernate 把它翻译成 SQL,而传给 [filter] 的 lambda 则是在 Java 程序内部执行的。

7.8. 结论

本章的要点:

  • 函数式接口是只有一个抽象方法的接口。[java.util.function] 包中的预定义接口([Function]、[Supplier]、[Consumer]、[Predicate]、它们的双参数变体及其基本类型版本),以及 [Runnable]、[Callable] 和 [Comparator],通常使您无需定义自己的接口;如果定义了,就用 [@FunctionalInterface] 注解它;
  • 函数式接口可以由类(具名或匿名)、lambda 表达式或方法引用([Class::staticMethod]、[object::method]、[Class::instanceMethod]、[Class::new])来实现。lambda 本身没有类型:由目标类型决定它的类型;
  • lambda 会捕获其周围的局部变量,前提是这些变量实际上是 final 的;可变状态通过对象或字段来处理;
  • 方法 [andThen]、[compose]、[and]、[negate]、[comparing]、[thenComparing]……可以根据现有函数构建新函数;
  • 在 Java 中,lambda 是接口的一个实例:函数式接口用于简短的一次性行为,而具有多个方法的接口(或“业务”接口)则用于应用程序的角色;
  • 事件通过监听器模式建立:一个 [XxxEvent] 类,派生自 [EventObject];一个接口 [XxxListener];方法 [addXxxListener] / [removeXxxListener], ;以及一个监听器列表([CopyOnWriteArrayList]),由方法 [fireXxx] 迭代它。要取消订阅某个监听器,必须保留已订阅的对象。[PropertyChangeSupport] 为属性变更提供了开箱即用的这种机制;
  • 流 API 建立在接受函数式接口的操作之上;Java 没有表达式树,Hibernate 用 HQL 或 Criteria API 来表达它的查询。

lambda 将在后续所有章节中再次出现:线程执行一个 [Runnable], 而 [ExecutorService] 执行 一个 [Callable] (第 8 章),[CompletableFuture] 把函数串联起来(第 9 章),Spring Boot Web 服务在框架作为监听器调用的方法中处理 HTTP 请求(第 13 章)。