Skip to content

7. 函数类型、lambda 与事件

在许多程序中,我们需要向函数传递的不是数据,而是行为:排序标准、过滤条件,或者在某件事发生时要执行的动作。Kotlin 通过把函数当作与其他值一样的值来满足这一需求:函数具有类型——即函数类型,例如记作 [(Int, Int) -> Int];它可以存储在变量中、作为参数传递、作为另一个函数的结果返回,并在需要时随时执行。接受或返回函数的函数称为高阶函数。

提醒一下,Java 没有函数类型:它依赖于函数式接口——只有一个抽象方法的接口([Runnable]、[Comparator]、[Function<T, R>]……),直到 Java 8(2014 年)才允许使用lambda 表达式 和方法引用来实现它们。Kotlin 从第一个版本起就支持 lambda,而且由于它直接使用 Java 库,所以也能使用 Java 的函数式接口。我们在第 5 章介绍的集合操作中已经大量使用了 lambda,只是没有深入细节:在 [persons.filter { it.age >= 18 }] 中,我们向函数 [filter] 传递了一个 lambda。本章解释这种语法背后的原理。本章最后讲述事件,Kotlin 与 Java 一样,使用“监听器”来处理事件:监听器是向发射器注册的函数(大多是 lambda),用于接收那里发生之事的通知。图形用户界面(Swing、JavaFX、Compose)和 Web 框架都依赖于这一机制:按钮点击或 HTTP 请求的到达会通知给已注册的监听器。本课程不涉及图形用户界面;所有示例都是控制台程序。

本章的程序组织在 Gradle 项目 [07-lambdas] 中,每个程序一个包:[src/main/kotlin/lambdas01/Lambdas01.kt]、[src/main/kotlin/lambdas02/Lambdas02.kt]……。它们通过 [gradlew -q run -Pmain=lambdas01.Lambdas01Kt] 运行,或者在 IntelliJ 或 IDEA 中点击绿色三角形运行。该项目除标准 Kotlin 库之外不需要任何库:函数类型、lambda 和作用域函数都已包含在内,而 [java.util.function] 包中的接口与 JDK 中的相同。

7.1. 函数类型与预定义的函数式接口

7.1.1. 函数类型的概念

函数类型 描述函数的模型(也称为签名或形式):括在括号中的参数类型,后面跟一个箭头,然后是返回值的类型。函数类型的变量可以引用任何这种形式的函数并执行它。下面是几个例子:

  • [() -> Unit]:没有参数、不返回有用结果的函数([Unit] 的作用相当于 Java 的 [void]);
  • [() -> String]:没有参数、返回字符串的函数;
  • [(Int) -> Boolean]:接受一个整数并返回布尔值的函数,换句话说,就是谓词;
  • [(Int, Int) -> Int]:接受两个整数并返回一个整数的函数;
  • [(String) -> (Int) -> Int]:接受一个字符串并返回……一个类型为 [(Int) -> Int] 的函数的函数(箭头从右向左读);
  • [(() -> Unit)?]:可能不存在的函数;括号是必需的,因为 [() -> Unit?] 否则表示返回 [Unit?] 的函数。在这里我们看到了第 3 章中与 [null] 相关的安全特性:这样的函数用 [f?.invoke()] 表示;
  • [String.(Int) -> String]:带接收者的函数;它作用于一个字符串——其代码中用 [this] 表示——就像扩展函数一样(第 4 章)。它既可以作为扩展来调用(["ab".f(3)]),也可以作为以接收者为第一个参数的普通函数来调用([f("ab", 3)])。

可以给参数命名,以便为类型提供说明:[(n1: Int, n2: Int) -> Int] 与 [(Int, Int) -> Int] 是同一个类型。

获得函数类型的值有三种方法:

  • 编写对具有正确形式的现有函数的引用:[val task: () -> Unit = ::display];
  • 编写 lambda 表达式:[val task: () -> Unit = { println("task") }];
  • 编写匿名函数:[val task = fun() { println("task") }],或者使用实现该函数类型的类的对象(函数类型是一个接口,我们稍后会看到)。这两种写法不太常见。

然后,函数像普通函数一样执行:[task()]。这是调用函数对象的方法 [invoke] 的简写形式:[task.invoke()]。这是与 Java 的第一个明显区别,在 Java 中你必须按名称调用接口的方法([run]、[apply]、[test]……);Kotlin 在这里的行为与 C# 相似,在 C# 中委托像方法一样被调用。

7.1.2. Kotlin 函数类型与 java.util.function 接口

在 Java 8 之前,每个 Java 库都定义自己的单方法接口([Runnable]、[Comparator]、[ActionListener]……)。Java 8 引入了 [java.util.function] 包,它提供了 43 个泛型函数式接口。Kotlin 不需要它们:函数类型可以直接书写。不过,这些接口仍然可以在 Kotlin 中使用,而且每当你调用 Java 库时都会遇到它们。下表给出了主要的 Java 接口与 Kotlin 函数类型之间的对应关系:

Java 接口
Kotlin 类型
所表示的函数
[Runnable]:[void run()]
[() -> Unit]
无参数,无结果
[Supplier<T>] :[T get()]
[() -> T]
无参数,一个结果:一个“供应者”
[Consumer<T>]:[void accept(T t)]
[(T) -> Unit]
一个参数,无结果:一个“消费者”
[BiConsumer<T, U>]
[(T, U) -> Unit]
两个参数,无结果
[Function<T, R>]:[R apply(T t)]
[(T) -> R]
一个参数,一个结果
[BiFunction<T, U, R>]
[(T, U) -> R]
两个参数,一个结果
[UnaryOperator<T>]
[(T) -> T]
参数和结果的类型相同
[BinaryOperator<T>]
[(T, T) -> T]
两个参数和一个结果,类型相同
[Predicate<T>]:[boolean test(T t)]
[(T) -> Boolean]
一个参数,布尔结果:一个“谓词”
[BiPredicate<T, U>]
[(T, U) -> Boolean]
两个参数,布尔结果
[Comparator<T>]:[int compare(T o1, T o2)]
[(T, T) -> Int]
两个类型相同的参数,整数结果
[Callable<V>] :[V call()]
[() -> V]
类似于 [Supplier<V>];在 Kotlin 中,无需声明受检异常
[IntBinaryOperator]、[IntPredicate]……
[(Int, Int) -> Int]、[(Int) -> Boolean]……
针对基本类型的 Java 版本

在 Kotlin 中,函数类型可以拥有的参数数量没有实际限制:[(Int, Int, Int) -> Int] 的写法与其他类型一样简单,而在 Java 中,由于没有预定义的三参数接口,你必须自己定义。

只认识类和接口的 Java 虚拟机如何表示函数类型?通过 Kotlin 库中的泛型接口:[kotlin.jvm.functions.Function0<R>]、[Function1<P1, R>]、[Function2<P1, P2, R>]……一直到 [Function22],再往后是接口 [FunctionN] 。每个接口都只有一个方法 [invoke]:[(Int, Int) -> Int] 被编译成 [Function2<Integer, Integer, Integer>],其方法是 [operator fun invoke(p1: Int, p2: Int): Int]。正是 [operator] 修饰符(作用于 [invoke] ,参见第 4 章的运算符重载)使得 [f(2, 3)] 这种写法成为可能。因此,对 JVM 来说,函数类型就是一个像 Java 中那样的函数式接口。由于 Java 泛型只适用于对象类型,[Int] 值在传给 [(Int, Int) -> Int] 时会被转换为 [Integer] ,反之亦然(装箱 和拆箱)。Java 通过其专门的接口([IntBinaryOperator]……)避免这些转换;Kotlin 则以另一种方式避免它们,即使用 [inline] 函数,我们稍后会讨论。

程序 [Lambdas01.kt] 通过函数引用使用这些类型:

package lambdas01

import java.util.function.IntBinaryOperator
import java.util.function.Predicate
import java.util.function.Supplier

// Kotlin 函数类型和 Java 函数式接口

fun main() {
    // 1 - () -> Unit:没有参数,没有结果
    val task: () -> Unit = ::display
    // 执行:函数像普通函数一样被调用
    task()
    // 这是调用其 invoke 方法的简写
    task.invoke()

    // 2 - (Int, Int) -> Int:两个参数,一个结果
    val operation: (Int, Int) -> Int = ::add
    println("operation(2, 3)=${operation(2, 3)}")
    // () -> String:没有参数,一个结果
    val greet: () -> String = ::greet
    println("greet()=${greet()}")

    // 3 - (String) -> Unit:一个参数,没有结果
    val write: (String) -> Unit = ::println
    write("(String) -> Unit executed println")

    // 4 - (Int) -> Boolean:谓词
    val isEven: (Int) -> Boolean = ::isEven
    println("isEven(8)=${isEven(8)}")
    val numbers = mutableListOf(3, 8, 1, 6, 5, 4)
    // Kotlin 库的 removeAll 期望一个 (Int) -> Boolean
    val modified = numbers.removeAll(isEven)
    println("even numbers removed: $modified, remaining: $numbers")

    // 5 - 由函数构建的 Comparator<T>(Java 接口)(SAM 转换)
    val names = mutableListOf("Paul", "Mélanie", "Jo", "Sébastien")
    names.sortWith(Comparator(::compareLengths))
    println("sorted by length: $names")

    // 6 - java.util.function 接口仍然可用
    val supplier: Supplier<String> = Supplier(::greet)
    val multiply = IntBinaryOperator(::multiply)
    val predicate = Predicate<Int> { it > 4 }
    println("supplier.get()=${supplier.get()}")
    println("multiply.applyAsInt(2, 3)=${multiply.applyAsInt(2, 3)}")
    // removeIf 是 Java 方法(Collection):它期望一个 Predicate
    val values = mutableListOf(10, 3, 8, 7, 2, 1)
    values.removeIf(predicate)
    // Kotlin 函数会被自动转换为 Predicate(SAM 转换)
    values.removeIf(isEven)
    values.removeIf { it == 1 }
    println("after removeIf: $values")

    // 7 - 可空函数类型:函数可能不存在
    execute(null)
    execute(task)

    // 8 - 带接收者的函数类型:String.(Int) -> String
    val times: String.(Int) -> String = String::repeat
    println("\"ab\".times(3)=${"ab".times(3)}, times(\"cd\", 2)=${times("cd", 2)}")

    // 9 - 函数是对象,是实现某个接口的类的实例
    println("class: ${operation::class.java.name}")
    println("interfaces: ${operation::class.java.interfaces.contentToString()}")
    val sum: (Int, Int) -> Int = { n1, n2 -> n1 + n2 }
    println("class of the lambda: ${sum::class.java.name}")
    println("interfaces: ${sum::class.java.interfaces.contentToString()}")
}

// 接收可能不存在的函数的函数
fun execute(callback: (() -> Unit)?) {
    // 安全调用:如果 callback 为 null,则什么也不执行
    callback?.invoke()
    println("callback ${if (callback == null) "absent" else "present"}")
}

// 被引用的函数:文件的顶层函数
fun display() {
    println("display() executed by task()")
}

fun add(n1: Int, n2: Int): Int = n1 + n2

fun multiply(n1: Int, n2: Int): Int = n1 * n2

fun greet(): String = "Hello"

fun isEven(n: Int): Boolean = n % 2 == 0

fun compareLengths(s1: String, s2: String): Int = s1.length.compareTo(s2.length)

结果:

> gradlew -q run -Pmain=lambdas01.Lambdas01Kt
display() executed by task()
display() executed by task()
operation(2, 3)=5
greet()=Hello
(String) -> Unit executed println
isEven(8)=true
even numbers removed: true, remaining: [3, 1, 5]
sorted by length: [Jo, Paul, Mélanie, Sébastien]
supplier.get()=Hello
multiply.applyAsInt(2, 3)=6
after removeIf: [3]
callback absent
display() executed by task()
callback present
"ab".times(3)=ababab, times("cd", 2)=cdcd
class: lambdas01.Lambdas01Kt$main$operation$1
interfaces: [interface kotlin.jvm.functions.Function2]
class of the lambda: lambdas01.Lambdas01Kt$$Lambda/0x000000001f04a7f0
interfaces: [interface kotlin.jvm.functions.Function2]

说明:

  • 第 11 行:变量 [task] 的类型是 [() -> Unit]。它被赋予一个函数引用:[::display] 引用文件后面(第 79 行)声明的顶层函数 [display] 。编译器验证它具有所需的形式(无参数、无返回值),并创建调用它的函数对象。在 Java 中,需要一个辅助类来包含这些方法,因为精简源文件的隐式类无法被命名;而在 Kotlin 中,顶层函数可以被直接引用;
  • 第 13 行:通过像普通函数一样调用来执行该函数。函数 [display] 被执行(结果的第 1 行)。第 15 行:通过显式调用方法 [invoke] 得到同样的结果(结果的第 2 行);
  • 第 18 行:[(Int, Int) -> Int] 引用一个有两个参数 [Int]、并返回 [Int] 的函数。函数 [add] (第 83 行)符合要求。该函数通过 [operation(2, 3)] 调用(第 19 行);
  • 第 21 行:一个无参数、返回字符串的函数,相当于 Java 的 [Supplier<String>]。请注意,局部变量 [greet] 与函数 [greet] 同名:在 [::greet] 中,它指的是函数,而在 [greet()] 中,它指的是局部变量,该变量遮蔽了函数;
  • 第 25 行:一个带有一个 [String] 参数、不返回任何内容的函数——相当于 Java 的 [Consumer<String>]。标准库函数 [println] 是重载的([println(Int)]、[println(Any?)]……):正是预期的类型 [(String) -> Unit] 让编译器选择正确的重载;
  • 第 29 行:一个谓词,等价于 [Predicate<Integer>]。第 33 行:Kotlin 库的扩展函数 [removeAll] 专门期望一个类型为 [(T) -> Boolean] 的参数:它从可变列表中删除谓词求值为 [true] 的所有元素,并且如果至少删除了一个元素,就返回 [true] (结果的第 7 行);
  • 第 38 行:函数 [sortWith] 期望一个 [Comparator<T>]。在 Kotlin 中,[Comparator] 是 Java 接口 [java.util.Comparator] 的别名。[Comparator(::compareLengths)] 根据函数 [compareLengths] 创建一个 [Comparator<String>] :这是一次 SAM 转换 (“Single Abstract Method”,单一抽象方法),它根据同样形式的 Kotlin 函数创建实现该 Java 接口的对象。函数 [compareLengths] (第 91 行)使用 [compareTo],它比较两个 [Int] 对象 而没有容量溢出的风险(简单的减法则不能保证这一点);
  • 第 42–44 行:*[java.util.function] 的接口可以原样使用。它们以同样的方式构造,即通过显式的 SAM 转换:接口名称后面跟一个函数引用或一个 lambda。然后它们像在 Java 中一样,通过其 Java 方法([get]、[applyAsInt]*、[test]……)来执行;
  • 第 49–52 行:[removeIf] 是 [Collection] 接口的 Java 方法;它期望一个 [Predicate]。你可以向它传递一个 *[Predicate] (第 49 行),也可以直接传递类型为 *[(Int) -> Boolean] 的值(第 51 行)或一个 lambda(第 52 行):当调用期望函数式接口的 Java 方法时,Kotlin 自动执行 SAM 转换。这使得在 Kotlin 中使用 Java 库与在 Java 中使用一样舒适。初始列表(10, 3, 8, 7, 2, 1)依次删除大于 4 的元素、偶数元素,然后是元素 1(结果的第 11 行);
  • 第 56–57 行和第 72–75 行:函数 *[execute] 接收一个可能不存在的函数,其类型为 *[(() -> Unit)?]。如果 [callback] 等于 [null],安全调用 [callback?.invoke()] 什么也不做。你不能写 [callback?()]:对可空函数的安全调用要通过 [invoke] 进行。这将是可选监听器的标准写法;
  • 第 60 行:一个带接收者的函数类型。引用 [String::repeat] 指向 [repeat] 方法(属于类 [String]),它作用于一个字符串并接受一个整数。第 61 行以两种方式引用:作为扩展,["ab".times(3)],或者作为带有两个参数的函数,[times("cd", 2)]。我们会在作用域函数 [apply] 和 [with] 中再次见到带接收者的函数;
  • 第 64–68 行:函数是一个对象。函数引用 [operation] 的类(输出的第 16 行)是由 Kotlin 编译器生成的类,以该引用出现的位置命名;lambda [sum] 的类(结果的第 18 行)由虚拟机在运行时生成,与 Java 的 lambda 一样:它的名称包含 [$$Lambda] ,后面跟着一个每次执行都会变化的地址。在这两种情况下,该类都实现了 [kotlin.jvm.functions.Function2] 接口(结果的第 17 行和第 19 行)。因此,Kotlin 函数并不是一种新类型的对象:它是实现某个函数式接口的普通类的实例。

7.2. 定义自己的函数类型

函数类型通常已经足够,但你可能希望给某个函数模型起一个名字。Kotlin 为此提供了两种工具,它们在本质上差别很大。

第一种是类型别名,使用关键字[typealias]声明:

  • [typealias BinaryOperation = (n1: Int, n2: Int) -> Int]

别名不会创建新类型:[BinaryOperation] 是[(Int, Int) -> Int]的另一个名字,这两种写法可以互换。当函数类型很长或频繁出现时,别名可以使代码更易读。

第二种是函数式接口,通过[fun interface]声明:

  • [fun interface Operation { fun calculate(n1: Int, n2: Int): Int }]

这完全等价于 Java 的函数式接口:只有一个抽象方法的接口(也称为SAM,即“Single Abstract Method”接口)。它也可以有带方法体的方法和非抽象属性,这些不计入其中。位于[fun] 之后的[interface] 与 Java 注解[@FunctionalInterface]作用相同,但有一个重要区别:它不是可选的。正是这个关键字启用了SAM 转换,即从 lambda 或函数引用创建 [Operation]对象:[Operation { n1, n2 -> n1 + n2 }]。如果没有关键字[fun],Kotlin 接口即使只有一个方法,也只能由类或匿名对象([object : Operation { … }])来实现。

与类型[(Int, Int) -> Int]相比,类型[Operation] 是真正的新类型,与其他所有类型都不同:它有一个描述其用途的名字,它的方法有一个具有描述性的名字([calculate] 而不是[invoke]),它可以有额外的方法,并且可以由具名类来实现。反过来,它是通过方法名来执行的([op.calculate(2, 3)]),而不是[op(2, 3)]。

名为[op] 、类型为[Operation]的变量,与类型为[(Int, Int) -> Int]的变量一样,一次只能引用一个函数。与提供“多播委托”的 C# 不同,Java 和 Kotlin 都没有提供在单个变量中存储多个函数并通过一次调用执行它们全部的方式:需要时,我们把这些函数存储在列表中,再逐个执行。我们处理事件监听器时正是这样做的。

来看示例[Lambdas02.kt]:

package lambdas02

import java.util.function.IntBinaryOperator

// 定义自己的函数类型:fun interface 和 typealias

fun main() {
    // Operation 类型的变量接收伴生对象的 increase 函数
    var op = Operation(Calculations::increase)
    // 执行该操作
    var n = op.calculate(4, 7)
    println("n=$n")

    // 创建 Calculations 类型的对象 c1
    val c1 = Calculations()
    // op 被赋予对象 c1 的 add 方法
    op = Operation(c1::add)
    n = op.calculate(2, 3)
    println("n=$n")
    // 然后是 c1 的 subtract 方法
    op = Operation(c1::subtract)
    n = op.calculate(2, 3)
    println("n=$n")

    // 一个变量只引用一个函数:要执行多个函数,使用列表
    val operations = listOf(
        Operation(c1::add),
        Operation(c1::subtract),
        Operation { n1, n2 -> n1 * n2 },
    )
    for (operation in operations) {
        println("-> ${operation.calculate(10, 4)}")
    }

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

    // Operation 和 IntBinaryOperator 形状相同,但是两个不同的类型
    val other = IntBinaryOperator(op::calculate)
    println("other.applyAsInt(5, 1)=${other.applyAsInt(5, 1)}")

    // 泛型函数式接口
    val length = Transformation(String::length)
    val stars = Transformation("*"::repeat)
    println("length(\"Hello\")=${length.transform("Hello")}")
    println("stars(5)=${stars.transform(5)}")

    // 类型别名:只是 (Int, Int) -> Int 的另一个名称
    val f: BinaryOperation = { n1, n2 -> n1 - n2 }
    // BinaryOperation 和 (Int, Int) -> Int 是同一个类型
    val g: (Int, Int) -> Int = f
    // 但 Operation 是不同的类型:需要转换
    val op2 = Operation(g)
    println("f(5, 1)=${f(5, 1)}, g(5, 1)=${g(5, 1)}, op2.calculate(5, 1)=${op2.calculate(5, 1)}")
}

// 函数式接口的定义:只有一个抽象方法
// 以两个整数为参数并返回一个整数
fun interface Operation {
    fun calculate(n1: Int, n2: Int): Int

    // 带方法体的方法不计入:该接口仍然是函数式的
    fun then(next: (Int) -> Int): Operation = Operation { n1, n2 -> next(calculate(n1, n2)) }
}

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

// 类型别名:不会创建新类型
typealias BinaryOperation = (n1: Int, n2: Int) -> Int

// 其方法具有 Operation 接口形状的类
class Calculations {
    // 两个实例方法
    fun add(n1: Int, n2: Int): Int {
        println("add($n1,$n2)")
        return n1 + n2
    }

    fun subtract(n1: Int, n2: Int): Int {
        println("subtract($n1,$n2)")
        return n1 - n2
    }

    // 伴生对象的方法:相当于静态方法
    companion object {
        fun increase(n1: Int, n2: Int): Int {
            println("increase($n1,$n2)")
            return n1 + 2 * n2
        }
    }
}

结果:

> gradlew -q run -Pmain=lambdas02.Lambdas02Kt
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)=*****
f(5, 1)=4, g(5, 1)=4, op2.calculate(5, 1)=4

注释:

  • 第 60–64 行:函数式接口[Operation]的定义。在 Kotlin 中,类型声明可以放在文件中的任何位置,位于函数[main]之前或之后均可;我们把它们放在后面;
  • 第 64 行:函数式接口可以有带方法体的方法(相当于 Java 的[default]方法)。方法[then] 构造一个新的[Operation]:该对象先执行当前运算,然后对其结果应用函数 [next]。它返回一个被转换为[Operation]的 lambda,我们将在下一节中研究。请注意,参数 [next]不需要像 Java 版本中的[IntUnaryOperator] 那样的接口:函数类型[(Int) -> Int] 就足够了,并且通过[next(…)]来执行;
  • 第 76–89 行:类[Calculations] 有两个实例方法[add] 和[subtract],以及其伴生对象的一个方法[increase] (相当于静态方法,见第 4 章),这三个方法的形式都与方法[calculate]相同;
  • 第 9 行:变量[op] 的类型为[Operation]。它被赋予的对象,是通过对引用[Calculations::increase]进行 SAM 转换得到的,该引用指向类[increase] 的伴生对象的方法[Calculations]。转换必须这样写:[Operation(Calculations::increase)] 看起来像构造函数调用,但接口并没有构造函数;实际上是编译器创建了实现[Operation]的对象;
  • 第 11 行:运算由 [calculate] 方法执行。实际执行的是[increase]方法,其参数就是传给 [calculate] 的参数;
  • 第 15 行:创建类[Calculations] 的一个实例,标识符为[c1];
  • 第 17 行:引用[c1::add] 指向 [add] 方法,它属于对象[c1]:这称为“绑定引用”。[increase] 是伴生对象的方法,而 [add] 是实例方法:这没有区别。在第二种情况下,编译器创建的对象还会存储将要调用该方法的对象[c1];
  • 第 21 行:对实例方法[subtract]做同样的处理;
  • 第 26–32 行:为了执行多个运算,把它们放入类型为[List<Operation>] 的列表中(类型由推断得出),然后遍历该列表。引用和 lambda 可以混用(第 29 行)。每个结果都会被取出(结果的第 7–11 行);
  • 第 36 行:方法 [then] 被应用于运算[Operation(c1::add)]。lambda[{ x -> x * x }] 被放在圆括号之外,因为它是 [then] 的最后一个(在这里也是唯一一个)参数:我们将在下一节更详细地解释这种语法。[squaredSum.calculate(1, 2)] 计算 (1+2)²,结果为 9(结果的第 12–13 行)。在 Java 中,必须显式写出转换[((Operation) c1::add).then(…)];在 Kotlin 中,显式的 SAM 转换就起到了这个作用;
  • 第 40 行:[Operation] 与 Java 接口[IntBinaryOperator] 形式完全相同,但它们是两个不同的类型,没有继承关系。赋值[val other: IntBinaryOperator = op] 会被拒绝([initializer type mismatch: expected 'IntBinaryOperator', actual 'Operation'])。相反,引用[op::calculate] 是类型为[(Int, Int) -> Int]的函数:SAM 转换把它变成一个 [IntBinaryOperator],它会调用[calculate]方法,该方法属于[op]对象(在程序的这个阶段为[c1::subtract] );
  • 第 68–69 行:函数式接口可以是泛型的。[Transformation<T, R>] 表示一个接受[T] 并返回 [R]的函数:这等价于[(T) -> R],只是名称由我们自己选择;
  • 第 44 行:[String::length] 引用类[length] 的属性[String]:引用既可以指向函数,也可以指向属性。它被当作类型为[(String) -> Int]的函数使用:将从作为参数传入的字符串中读取该属性。[T = String] 和[R = Int] 这两个[Transformation] 的类型是从该引用推断出来的。第 45 行:["*"::repeat] 引用字符串对象[repeat(Int)] 的方法["*"]:它接受一个整数并返回一个字符串。这是两种不同类型的引用(未绑定引用和绑定引用),我们将在下一节详细讨论;
  • 第 73 行:类型别名。名为[n1] 和[n2] 的参数仅用于文档说明;
  • 第 50–54 行:类型为[f] 的 lambda[BinaryOperation] 无需转换就被赋给类型为[g] 的变量[(Int, Int) -> Int]:它们是同一个类型。但要把它转换为 [Operation],则需要 SAM 转换(第 54 行)。

这些规则可以通过故意触发错误来验证。如果你不进行显式转换而写下 ***[var op: Operation = Calculations::increase]***,编译器会拒绝它:

1
2
3
Lambdas02.kt:9:23: error: initializer type mismatch: expected 'Operation', actual 'KFunction2<Int, Int, Int>'.
    var op: Operation = Calculations::increase
                      ^

该消息还揭示了函数引用的类型:[KFunction2<Int, Int, Int>],这是一个 Kotlin 反射类型([kotlin.reflect]),它同时也是一个[(Int, Int) -> Int]。隐式 SAM 转换只发生在函数调用的实参上(例如[values.removeIf(isEven)]),而不发生在赋值上。

如果不小心向接口[fun invert(n: Int): Int]中添加了第二个抽象方法,例如[Operation],编译器会标记声明本身以及每一处使用该接口的 SAM 转换(输出已缩略):

1
2
3
4
5
6
7
8
Lambdas02.kt:9:14: error: interface 'fun interface Operation : Any' does not have constructors.
    var op = Operation(Calculations::increase)
             ^^^^^^^^^
...
Lambdas02.kt:60:1: error: functional interface must have exactly one abstract function.
fun interface Operation {
^^^
...

这些消息来自[kotlinc]编译器;Gradle 在显示它们时会在前面加上[e:] 和完整的文件路径。与来自[javac]的消息一样,它们是英文的。

7.3. 匿名对象、lambda 表达式和引用

7.3.1. 从匿名对象到 lambda

在前面的示例中,每个函数都是在程序其他位置定义的具名函数。对于只使用一次的简短函数,这样做很繁琐。Java 最初提供了匿名类:实现接口的类就在创建对象的地方定义。Kotlin 有一个等价物——对象表达式[object : Type { … }],已在第 4 章中介绍——但很少用它来表示函数:Kotlin 从一开始就支持lambda 表达式,其语法要简洁得多。程序[Lambdas03.kt] 演示了各种形式:

package lambdas03

// 从匿名对象到 lambda 表达式

fun main() {
    // 1 - 匿名对象:就地编写实现函数类型的类
    val add = object : (Int, Int) -> Int {
        override fun invoke(n1: Int, n2: Int): Int {
            return n1 + n2
        }
    }
    println("anonymous object: add(2, 3)=${add(2, 3)}")

    // 2 - 用 lambda 表达式做同样的事:{ parameters -> body }
    val subtract = { n1: Int, n2: Int -> n1 - n2 }
    println("lambda with typed parameters: subtract(2, 3)=${subtract(2, 3)}")

    // 3 - 参数类型由期望的类型推断
    val multiply: (Int, Int) -> Int = { n1, n2 -> n1 * n2 }
    println("lambda with untyped parameters: multiply(2, 3)=${multiply(2, 3)}")

    // 4 - 单个参数:无需命名,此时称为 it
    val square: (Int) -> Int = { it * it }
    val isEmpty: (String) -> Boolean = { s -> s.isEmpty() }
    println("square(7)=${square(7)}, isEmpty(\"\")=${isEmpty("")}")

    // 5 - 没有参数:没有箭头
    val greet = { "Hello" }
    val beep = { println("beep!") }
    println(greet())
    beep()

    // 6 - 由多条语句组成的函数体:最后一个表达式的值就是结果
    val repeat: (String, Int) -> String = { text, times ->
        val buffer = StringBuilder()
        for (i in 1..times) {
            buffer.append(text)
        }
        buffer.toString()
    }
    println(repeat("ab", 3))

    // 7 - 未使用的参数:_
    val listener: (Any?, String) -> Unit = { _, _ -> println("event received") }
    listener(null, "click")

    // 8 - 作为参数传递的 lambda:如果它是最后一个参数,则放在括号之外
    val numbers = mutableListOf(3, 8, 1, 6, 5, 4)
    val evens = numbers.filter { it % 2 == 0 }
    println("evens: $evens")
    numbers.sortWith { n1, n2 -> n2.compareTo(n1) }
    println("descending order: $numbers")
    // lambda 在括号之外,位于其他参数之后
    val total = numbers.fold(0) { acc, n -> acc + n }
    println("total: $total")

    // 9 - lambda 中的 return:return@label 只退出该 lambda
    numbers.forEach {
        if (it % 2 == 0) return@forEach
        print("$it ")
    }
    println("<- odds")
    // 由开发者选择的标签
    numbers.forEach odd@{ n ->
        if (n % 2 != 0) return@odd
        print("$n ")
    }
    println("<- evens")
    // 匿名函数:其中的 return 退出该匿名函数
    val isLarge = fun(n: Int): Boolean {
        if (n > 5) return true
        return false
    }
    println("large: ${numbers.filter(isLarge)}")

    // 10 - 解构 lambda 的参数
    val ages = mapOf("Paul" to 40, "Mélanie" to 35)
    ages.forEach { (name, age) -> println("$name is $age years old") }
}

结果:

> gradlew -q run -Pmain=lambdas03.Lambdas03Kt
anonymous object: add(2, 3)=5
lambda with typed parameters: subtract(2, 3)=-1
lambda with untyped parameters: 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]
total: 27
5 3 1 <- odds
8 6 4 <- evens
large: [8, 6]
Paul is 40 years old
Mélanie is 35 years old

注释:

  • 第 7–12 行:一个匿名对象。关键字[object] 后面跟着冒号和要实现的类型——这里是函数类型[(Int, Int) -> Int](正如我们所见,它是一个接口),以及一个类的主体,该类通过重新定义其方法[invoke]来实现这个类型。编译器生成一个无名类并创建它的一个实例。用六行代码来表达[n1 + n2]。然而它像函数一样被执行:[add(2, 3)];
  • 第 15 行:用 lambda 表达式做同样的事。lambda 写在花括号之间:参数列表、[->]运算符(一个箭头,读作“得到”),然后是函数体。类型名和方法名都消失了。由于参数有类型,编译器可以自行确定 lambda 的类型:[(Int, Int) -> Int]。这与 Java 不同,在 Java 中 lambda 永远没有自己的类型;
  • 第 19 行:省略了参数类型。编译器根据为变量声明的期望类型来推断它们:[n1] 和[n2] 的类型是[Int]。这是最常见的形式。在 Kotlin 中,不像 Java 那样区分“表达式体”和“块体”:lambda 的主体是一系列语句,最后一个表达式的值就是 lambda 的结果;
  • 第 23 行:只有一个参数时,根本不需要声明它,也不需要箭头;它会被隐式命名为[it] (“it”,即“它”)。[{ it * it }] 读作“它的平方”。第 24 行:单个参数被命名为[s]。当[it] 会降低代码可读性时就这样做,特别是在 lambda 嵌套的情况下(每个 lambda 都有自己的[it]);
  • 第 28–29 行:没有参数时,不写箭头。*[greet]* 的类型被推断为 *[() -> String]*;*[beep] 的类型是 *[() -> Unit]*,因为 *[println] 产生 *[Unit]*;
  • 第 34–39 行:lambda 可以包含任何指令:声明、循环、测试等。最后一个表达式的值[buffer.toString()]就是结果。你不能写[return buffer.toString()]:在 lambda 中,不带标签的[return] 不会退出 lambda(见下文);
  • 第 44 行:下划线字符[_] 表示未使用的参数。当类型签名要求有 lambda 并不需要的参数时就使用它,这在事件监听器中很常见。你可以在同一个 lambda 中包含多个这样的参数(Java 在 22 版中采用了这种语法);
  • 第 48–49 行:lambda 最常见的用法是直接作为参数传给高阶函数。当 lambda 是最后一个参数时,它写在圆括号之外;如果没有其他参数,则省略圆括号:[numbers.filter { it % 2 == 0 }],而不是 [numbers.filter({ it % 2 == 0 })]。正是这条规则赋予了 Kotlin 代码独特的外观,并使你能够编写类似语言语句的函数([repeat]、[use]、[thread]、[synchronized]……)。与[Lambdas01.kt]比较一下:不再需要编写函数[isEven]了;
  • 第 51 行:一个反转通常比较顺序的 lambda:列表按降序排序。[sortWith] 需要一个[Comparator] (一个 Java 接口):SAM 转换会自动完成;
  • 第 54 行:当函数还有其他参数时,lambda 仍留在圆括号之外:[fold(0) { acc, n -> acc + n }]。函数[fold] (第 5 章)从初始值 0 开始,逐个累加元素;
  • 第 58–62 行:在 lambda 内,语句[return@forEach] 退出该 lambda(从而转到下一个元素),就像循环中的[continue] 一样。标签[@forEach] 是隐式的:它就是接收该 lambda 的函数的名称。不带标签的[return] 会退出整个函数[main]:这称为非局部返回,并且只允许出现在传给[inline] 或[forEach] 这类函数的 lambda 中(我们将看到原因);
  • 第 64–68 行:你也可以通过把标签放在左花括号之前来自行选择标签:[odd@{ … }],然后 [return@odd];
  • 第 70–74 行:一个匿名函数。它的写法与普通函数一样,只是没有名称。它的类型是推断出来的:[(Int) -> Boolean]。在匿名函数中,[return] 退出的是匿名函数本身。当函数体有多个出口,或者想显式指定结果类型时,就会用到它;
  • 第 78 行:lambda 的参数可以被解构(第 3 章)。传给[forEach] 的 lambda 接收关联数组的一个条目([Map.Entry<String, Int>]);用圆括号括起来的写法[(name, age)]把它分解为键和值。注意:[{ name, age -> … }] 会声明两个参数,而[{ (name, age) -> … }] 会声明一个被解构的参数。

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

形式
示例
带类型的参数
[{ a: Int, b: Int -> a + b }]
不带类型的参数(期望类型已知)
[{ a, b -> a + b }]
单个隐式参数
[{ it * it }]
无参数
[{ "Hello" }]
未使用的参数
[{ _, _ -> println("received") }]
解构参数
[{ (key, value) -> "$key=$value" }]
多条语句
[{ x -> println(x) ; x * 2 }]
lambda 作为最后一个参数
[list.filter { it > 0 }]
匿名函数
[fun(x: Int): Int { return x * 2 }]

lambda 并不完全是匿名对象的简写。在匿名对象中,[this] 指的是匿名对象本身;在 lambda 中,[this] 指的是包围该 lambda 的方法所属的对象(对于带接收者的 lambda,则是接收者)。此外,匿名对象可以实现带有多个方法的接口、同时实现多个接口,或者继承某个类——这些对 lambda 来说都不可能。在本课程中,我们将尽可能使用 lambda。

7.3.2. 补充说明:类型推断和引用

程序[Lambdas04.kt] 解释了 lambda 的类型是如何确定的,并描述了不同类型的引用:

package lambdas04

import java.io.IOException
import java.util.concurrent.Callable
import java.util.function.Supplier

// 关于 lambda 和引用的更多内容

fun main() {
    // 1 - lambda 的类型由其参数和函数体推断……
    val double = { x: Int -> x * 2 }
    println("double(21)=${double(21)}")
    // ……或由期望的类型确定:同一段 lambda 文本可以得到三种不同的类型
    val function: () -> String = { "Hello" }
    val supplier = Supplier { "Hello" }
    val callable = Callable { "Hello" }
    println("${function()} / ${supplier.get()} / ${callable.call()}")

    // 2 - 引用的种类
    // a) 顶层函数:::function
    val triple: (Int) -> Int = ::triple
    println("triple(14)=${triple(14)}")
    // b) 给定对象的方法或属性(绑定引用):object::method
    val name = "Pierre"
    val inUpperCase: () -> String = name::uppercase
    val nameLength: () -> Int = name::length
    println("inUpperCase()=${inUpperCase()}, nameLength()=${nameLength()}")
    // c) 类的任意对象的方法(未绑定引用):Class::method
    //    调用该方法的对象成为第一个参数
    val upperCase: (String) -> String = String::uppercase
    val ignoreCase: (String, String) -> Int = { s1, s2 -> s1.compareTo(s2, ignoreCase = true) }
    println("upperCase(\"paul\")=${upperCase("paul")}")
    println("ignoreCase(\"abc\", \"ABC\")=${ignoreCase("abc", "ABC")}")
    // d) 扩展函数:Class::extension
    val convert: (String) -> Int = String::toInt
    println("convert(\"42\") + 1 = ${convert("42") + 1}")
    // e) 构造函数:::Class
    val createList: () -> MutableList<String> = ::ArrayList
    val createBuffer: (String) -> StringBuilder = ::StringBuilder
    val createArray: (Int) -> IntArray = ::IntArray
    val createPerson: (String, Int) -> Person = ::Person
    val list = createList()
    list.add("element")
    println("$list ${createBuffer("abc").reverse()} ${createArray(3).size} ${createPerson("Paul", 40)}")

    // 3 - 没有受检异常:任何 lambda 都可以抛出任何异常
    val read: () -> Int = { throw IOException("file missing") }
    try {
        read()
    } catch (ex: IOException) {
        println("exception received: ${ex.message}")
    }

    // 4 - 函数的相等性:引用可以比较,lambda 不可以
    val r1: () -> String = name::uppercase
    val r2: () -> String = name::uppercase
    val l1 = { name.uppercase() }
    val l2 = { name.uppercase() }
    println("r1 == r2 : ${r1 == r2}, r1 === r2 : ${r1 === r2}, l1 == l2 : ${l1 == l2}")
}

fun triple(n: Int) = n * 3

// 数据类,用于对其构造函数的引用
data class Person(val name: String, val age: Int)

结果:

> gradlew -q run -Pmain=lambdas04.Lambdas04Kt
double(21)=42
Hello / Hello / Hello
triple(14)=42
inUpperCase()=PIERRE, nameLength()=6
upperCase("paul")=PAUL
ignoreCase("abc", "ABC")=0
convert("42") + 1 = 43
[element] cba 3 Person(name=Paul, age=40)
exception received: file missing
r1 == r2 : true, r1 === r2 : false, l1 == l2 : false

注释:

  • 第 11 行:lambda[{ x: Int -> x * 2 }] 有它自己的类型[(Int) -> Int],由其参数的类型和函数体的类型计算得出。另一方面,声明[val double = { x -> x * 2 }],会被拒绝:编译器无法推断[x] 的类型([an explicit type is required on a value parameter])。在 Java 中,[var twice = x -> x * 2;] 被拒绝的原因更为根本:Java 的 lambda 不能没有目标类型,目标类型指明了要实现的接口;
  • 第 14–16 行:同一个 lambda 表达式[{ "Hello" }]在这里产生[() -> String],在那里产生[Supplier<String>],在另一处产生[Callable<String>]。在后两种情况下,是放在 lambda 之前的 Java 接口名称触发了 SAM 转换。这是三个不同类的对象,它们只共享方法的形式;
  • 第 19–41 行:引用的各种类型。Kotlin 称它们为“可调用引用”:它们指向函数,也可以指向属性和构造函数:
    • 第 21 行:对顶层函数的引用,[::function]。[::triple] 等价于 lambda [{ n -> triple(n) }]。它取代了 Java 中对静态方法的引用([Class::staticMethod])。对于伴生对象的函数,我们写成[Class::function],如[Lambdas02.kt]中所示;
    • 第 25–26 行:对给定对象的方法或属性的引用,[object::method],称为绑定引用。[name::uppercase] 等价于 [{ name.uppercase() }]:对象 [name]被一次性固定下来。[name::length] 引用属性[length],它属于字符串 [name];
    • 第 30–31 行:对类的任意对象的方法的引用,[Class::method],称为未绑定引用。调用该方法的对象尚不确定:它成为函数的第一个参数。[String::uppercase] 等价于[{ s: String -> s.uppercase() }]。对于[ignoreCase],这里选用了 lambda,这样就可以把名为[ignoreCase = true]的实参传给[compareTo];
    • 第 35 行:扩展函数像方法一样被引用:[String::toInt] 等价于[{ s: String -> s.toInt() }];
    • 第 38–41 行:对构造函数的引用,[::Class](在 Java 中为 [Class::new])。[::ArrayList] 等价于[{ ArrayList() }];[::StringBuilder]在期望类型为[(String) -> StringBuilder]时,会选择接受字符串的构造函数;[::IntArray] 创建一个大小为所传参数的整数数组;[::Person] 引用 [Person]数据类的主构造函数(第 65 行);
  • 第 44 行:使用创建函数;[reverse] 反转[StringBuilder] 的内容(结果的第 8 行);
  • 第 47–51 行:Kotlin 不支持受检异常(第 3 章)。因此,类型为[() -> Int] 的 lambda 可以抛出 [IOException]而无需声明任何内容。在 Java 中,这曾是一个真正的难题:没有任何[java.util.function]接口允许受检异常,而类型为[Supplier<Integer>] 、抛出 [IOException]的 lambda 会被拒绝;因此我们不得不使用[Callable],它的方法被声明为[throws Exception]。还要注意,lambda[{ throw IOException("file missing") }] 被接受为[() -> Int]:表达式[throw] 的类型是[Nothing],它与所有类型兼容;
  • 第 55–59 行:对同一个引用 ***[name::uppercase] 求值两次会产生两个不同的对象([r1 === r2] 等于 *[false]*),但与 Java 不同,Kotlin 认为它们在*相等的意义上,即按[equals] 来说([r1 == r2] 等于[true])是相等的:如果两个引用指向同一个函数,并且关联的是同一个对象,则它们相等。两个 lambda 即使文本完全相同,也永远不相等(结果的第 10 行)。请记住这一点:在注销事件监听器时它会很重要。最后请注意,必须写出 *[r1] 的类型:函数[uppercase] 是重载的([uppercase()] 和[uppercase(locale: Locale)]),在没有期望类型的情况下,编译器拒绝做出选择([overload resolution ambiguity between candidates]*)。

引用只是一种简写形式,用来表示仅仅调用某个函数的 lambda。当它能提高可读性时就使用它:[String::length] 而不是[{ it.length }]。实际上,有了[it],Kotlin 的 lambda 非常简短,因此引用的使用频率比 Java 中略低。

7.3.3. 组合函数

Java 的函数式接口具有[default] 方法和[static] 方法,可以由现有函数创建新函数:[andThen]、[compose]、[and]、[or]、[negate]……Kotlin 的函数类型没有这些方法:标准库没有为[andThen] 提供函数,也就是对于[(A) -> B]而言。但自己编写它们非常容易,只需把它们写成函数类型上的扩展函数(第 4 章),因为函数可以返回函数。程序[Lambdas05.kt] 演示了这一点,然后介绍 Kotlin 库中用于构建比较器的函数:

package lambdas05

import java.util.function.Function

// 函数的组合:返回函数的函数

fun main() {
    // 1 - 组合:我们的扩展 then(先 this,再另一个)和 after(先另一个)
    val plusOne: (Int) -> Int = { it + 1 }
    val timesTwo: (Int) -> Int = { it * 2 }
    println("(plusOne then timesTwo)(5)=${(plusOne then timesTwo)(5)}")
    println("(plusOne after timesTwo)(5)=${(plusOne after timesTwo)(5)}")
    // Java Function 接口的方法仍然可用
    val f = Function<Int, Int> { it + 1 }.andThen { it * 2 }
    println("Function.andThen: f.apply(5)=${f.apply(5)}")
    // 生成函数的函数
    val plusTen = adder(10)
    println("adder(10)(5)=${plusTen(5)}, adder(3)(5)=${adder(3)(5)}")
    // 由函数列表构建的处理链
    val steps: List<(String) -> String> = listOf(String::trim, String::lowercase, { it.replace(' ', '-') })
    val normalize = steps.fold({ s: String -> s }) { function, step -> function then step }
    println("normalize(\"  My Nice Title \")=${normalize("  My Nice Title ")}")

    // 2 - 谓词:我们的扩展 and、or、not
    val short: (String) -> Boolean = { it.length <= 4 }
    val startsWithP: (String) -> Boolean = { it.startsWith("P") }
    val firstNames = listOf("Paul", "Mélanie", "Jo", "Sébastien", "Pierre")
    println("short and P: ${filterElements(firstNames, short and startsWithP)}")
    println("short or P: ${filterElements(firstNames, short or startsWithP)}")
    println("not short: ${filterElements(firstNames, !short)}")
    // CharSequence 上的谓词适合用于过滤 String
    val notEmpty: (CharSequence) -> Boolean = { it.isNotEmpty() }
    println("not empty: ${filterElements(listOf("a", "", "b"), notEmpty)}")

    // 3 - 对同一个值进行多次处理
    val log = mutableListOf<String>()
    val display: (String) -> Unit = { println("display: $it") }
    val remember: (String) -> Unit = { log.add(it) }
    val both = display andAlso remember
    both("first")
    both("second")
    println("log: $log")

    // 4 - 比较器:compareBy、thenBy、thenByDescending、reversed
    val persons = mutableListOf(Person("Paul", 32), Person("Mélanie", 25),
        Person("Jo", 32), Person("Sébastien", 25))
    persons.sortWith(compareBy(Person::age).thenBy(Person::name))
    println("by age then name: $persons")
    persons.sortWith(compareBy(Person::age).reversed().thenByDescending(Person::name))
    println("by descending age then descending name: $persons")
    // 同时使用多个条件
    persons.sortWith(compareBy({ it.name.length }, { it.name }))
    println("by name length then name: $persons")
    // 比较器也可用于在两个元素中选出较小的一个
    val byAge = compareBy(Person::age)
    println("younger of Paul and Mélanie: ${minOf(persons[1], persons[2], byAge)}")
}

// 组合:先 this,再 next
infix fun <A, B, C> ((A) -> B).then(next: (B) -> C): (A) -> C = { x -> next(this(x)) }

// 反向组合:先 before,再 this
infix fun <A, B, C> ((B) -> C).after(before: (A) -> B): (A) -> C = { x -> this(before(x)) }

// 谓词上的逻辑运算
infix fun <T> ((T) -> Boolean).and(other: (T) -> Boolean): (T) -> Boolean = { this(it) && other(it) }

infix fun <T> ((T) -> Boolean).or(other: (T) -> Boolean): (T) -> Boolean = { this(it) || other(it) }

operator fun <T> ((T) -> Boolean).not(): (T) -> Boolean = { !this(it) }

// 对同一个值连续进行两次处理
infix fun <T> ((T) -> Unit).andAlso(other: (T) -> Unit): (T) -> Unit = { this(it); other(it) }

// 返回函数的函数
fun adder(n: Int): (Int) -> Int = { it + n }

// 保留满足谓词的元素
fun <T> filterElements(elements: List<T>, predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (element in elements) {
        if (predicate(element)) {
            result.add(element)
        }
    }
    return result
}

data class Person(val name: String, val age: Int) {
    override fun toString() = "$name($age)"
}

结果:

> gradlew -q run -Pmain=lambdas05.Lambdas05Kt
(plusOne then timesTwo)(5)=12
(plusOne after timesTwo)(5)=11
Function.andThen: f.apply(5)=12
adder(10)(5)=15, adder(3)(5)=8
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)]
by name length then name: [Jo(32), Paul(32), Mélanie(25), Sébastien(25)]
younger of Paul and Mélanie: Mélanie(25)

注释:

  • 第 60 行:扩展函数[then] 应用于类型为[(A) -> B] 的函数(函数类型两边的圆括号是必需的),并接受一个类型为[next] 的函数[(B) -> C]。它返回一个类型为[(A) -> C]的新函数——即 lambda[{ x -> next(this(x)) }]——它先应用函数[this] (扩展的接收者),然后对其结果应用[next] 。这就是 Java 接口[andThen] 的方法[Function]。类型为[A]、[B]和[C] 的三个参数是泛型的:[then] 可以组合任何单参数函数,只要第一个函数的结果适用于第二个函数。修饰符[infix] 使你可以写成[f then g],而不是 [f.then(g)];
  • 第 63 行:反向组合,等价于 Java 方法[compose]:[f after g] 先应用[g],然后应用[f];
  • 第 11 行:[plusOne then timesTwo] 返回的函数先应用[plusOne],然后对结果应用[timesTwo]:(5 + 1) × 2 = 12。组合表达式两边的圆括号是必需的,这样才能调用得到的函数;
  • 第 12 行:[plusOne after timesTwo] 先应用[timesTwo],然后应用[plusOne]:5 × 2 + 1 = 11;
  • 第 14 行:如果你更喜欢 Java 接口的方法,只需通过 SAM 转换创建一个[Function] :这样[andThen] 就可用了,你可以向它传入一个 Kotlin lambda,它会被相应转换。结果是一个 *[Function],通过 *[apply]来执行;
  • 第 17–18 行和第 76 行:[adder] 是一个返回函数的函数:[adder(10)] 返回一个给其参数加 10 的函数。返回的函数可以存储在变量([plusTen])中,也可以立即调用:[adder(3)(5)]。这种固定一个参数以得到关于其余参数的函数的过程,称为部分应用;
  • 第 20–21 行:动态构造的处理链。我们从恒等函数([{ s: String -> s }],它原样返回其参数)开始,并借助[then],通过函数[fold] (第 5 章)把列表中的每个步骤依次加入其中:累加值[function]在这里是一个函数。得到的函数[normalize] 会去除首尾空格([trim]),把文本转换为小写,并把空格替换为连字符。每次调用[then] 都会创建一个新函数:现有函数永远不会被修改。同样,步骤列表也可以从配置文件中读取;
  • 第 66–70 行:谓词通过我们的扩展[and]、[or]和[not]来组合。后者被声明为[operator]:它就是运算符[!] 所调用的函数(参见第 4 章中的运算符重载)。因此,[!short] 表示对谓词 [short] 取反(第 30 行)。在 Java 中,写作[isShort.negate()],而对于方法引用则写作[Predicate.not(String::isEmpty)] ;
  • 第 32–33 行:类型为[(CharSequence) -> Boolean] 的谓词被[filterElements] 接受,用于过滤一个[String]列表,尽管该参数被声明为[(T) -> Boolean] ,其中[T = String]。这是因为 Kotlin 的函数类型在参数上是逆变的,在结果上是协变的(第 4 章):[(T) -> R] 实际上是[Function1<in T, out R>]。能够处理任何[CharSequence] 的函数也能处理[String]。在 Java 中,你必须把参数声明为[Predicate<? super T>] 才能达到这个效果;在 Kotlin 中,这是自动发生的;
  • 第 36–42 行和第 73 行:[andAlso] 扩展返回一个对同一个值依次执行两个操作的函数,类似于 Java 接口[andThen] 的方法[Consumer]。这是通过一次调用执行多个操作的最简单方式。请注意,lambda[{ this(it); other(it) }] 在同一行上有两条语句,用分号分隔;
  • 第 47 行:Kotlin 库中的[compareBy(f)] 函数构造一个比较器,用来比较[f] 的值(这里是 age);[thenBy] 指定出现平局时使用的次要比较条件(这里是 name)。它们相当于 Java 中的[Comparator.comparing] 和[thenComparing]。引用[Person::age] 和 [Person::name]指向数据类 [Person]的属性(第 89–90 行),我们为该类重新定义了方法[toString] 以缩短输出;
  • 第 49 行:[reversed] 反转到目前为止得到的顺序,而[thenByDescending] 添加一个按降序排列的条件;
  • 第 52 行:[compareBy] 也接受多个以 lambda 表达式形式给出的条件,并按顺序应用:这里先是名字的长度,然后是名字本身。这是作为实参传入的两个 lambda,因为[compareBy] 通过名为[vararg]的参数来接收它们;
  • 第 55–56 行:函数[minOf] 根据作为第三个参数传入的比较器,返回前两个参数中较小的一个(在 Java 中为[BinaryOperator.minBy]);
  • 第 79–86 行:用于这些测试的函数[filterElements]。这是一个高阶函数,它的作用与库函数[filter] 相同:它对每个元素应用谓词[predicate] ——把它当作普通函数来调用——并保留使其返回[true]的元素。

这些函数使你无需编写任何类,就能通过组合简单函数来编写复杂的处理逻辑。在讨论集合和序列时,我们会再回到它们。

7.3.4. 变量捕获与闭包

lambda 可以使用编写它的函数中的局部变量。这称为捕获这些变量。在这方面,Kotlin 与 Java 有显著不同。Java 要求被捕获的局部变量必须是“实际上的 final”:它在初始化之后永远不会被修改,无论是在方法中还是在 lambda 中。Kotlin 与 C#、JavaScript 或 Python 一样,没有这样的限制:lambda 可以捕获[var]变量,即使在它改变之后也能读取它,甚至可以修改它。程序[Lambdas06.kt] 演示了这种自由所允许的操作、它是如何实现的,以及随之而来的陷阱:

package lambdas06

// 捕获变量和闭包

// 顶层变量:lambda 可以修改它
var nbCalls = 0

fun main() {
    // 1 - lambda 可以使用其周围的局部变量
    val threshold = 5
    val exceeds: (Int) -> Boolean = { n -> n > threshold }
    println("threshold=$threshold : exceeds(7)=${exceeds(7)}")

    // 2 - 在 Kotlin 中,被捕获的变量可以是 var……
    var variableThreshold = 5
    val exceedsVariable: (Int) -> Boolean = { n -> n > variableThreshold }
    println("variableThreshold=$variableThreshold : exceedsVariable(7)=${exceedsVariable(7)}")
    // ……此时 lambda 看到的是变量在其运行时的值
    variableThreshold = 10
    println("variableThreshold=$variableThreshold : exceedsVariable(7)=${exceedsVariable(7)}")

    // 3 - lambda 可以修改被捕获的局部变量
    var total = 0
    val accumulate: (Int) -> Unit = { n -> total += n }
    accumulate(3)
    accumulate(4)
    println("total=$total")
    // 被捕获的变量存储在 Ref 对象中,由 lambda 持有
    println("fields of the lambda: ${accumulate::class.java.declaredFields.map { it.type.name }}")
    // 顶层变量(或属性)同样可以被修改
    val count = { nbCalls++ }
    count()
    count()
    println("nbCalls=$nbCalls")

    // 4 - 闭包:被捕获的变量比创建它的函数存活得更久
    val counterA = createCounter()
    val counterB = createCounter()
    println("A: ${counterA()} ${counterA()} ${counterA()}")
    println("B: ${counterB()} ${counterB()}")

    // 5 - for 循环在每次迭代时声明一个新的变量 i
    val actions = mutableListOf<() -> Unit>()
    for (i in 0..2) {
        actions.add { print("$i ") }
    }
    print("for: ")
    actions.forEach { it() }
    println()

    // 陷阱:所有 lambda 共享同一个 var
    actions.clear()
    var k = 0
    while (k < 3) {
        actions.add { print("$k ") }
        k++
    }
    print("while, capture of the var k: ")
    actions.forEach { action -> action() }
    println()
}

// 返回函数的函数
fun createCounter(): () -> Int {
    // 被返回的 lambda 捕获的局部变量
    var value = 0
    return { ++value }
}

结果:

> gradlew -q run -Pmain=lambdas06.Lambdas06Kt
threshold=5 : exceeds(7)=true
variableThreshold=5 : exceedsVariable(7)=true
variableThreshold=10 : exceedsVariable(7)=false
total=7
fields of the lambda: [kotlin.jvm.internal.Ref$IntRef]
nbCalls=2
A: 1 2 3
B: 1 2
for: 0 1 2
while, capture of the var k: 3 3 3

注释:

  • 第 11 行:lambda 使用第 10 行声明的局部变量[threshold]。[threshold] 不是 lambda 的参数;它是一个被捕获的变量。由于它是[val],lambda 在创建时只是接收其值的一个副本,与 Java 完全一样;
  • 第 15–19 行:这一次,lambda 捕获的是一个 *[var]*,Java 会拒绝这种做法(*[local variables referenced from a lambda expression must be final or effectively final])。它接收的不是值的副本,而是与函数[main]共享该变量:当[variableThreshold] 变为 10 时(第 19 行),同一个 lambda 返回了不同的结果(结果的第 2–3 行)。因此,lambda 函数看到的是变量在其执行时刻的值*,而不是它被创建时刻的值。这正是 Java 通过禁止这类捕获所要避免的问题;
  • 第 23–27 行:lambda[accumulate] 修改局部变量[total]。在 Java 中,你必须使用可变对象([AtomicInteger],或者使用单元素数组这种变通办法);在 Kotlin 中,你可以直接写[total += n];
  • 第 29 行:既然虚拟机本身只允许捕获值,这是如何做到的?Kotlin 编译器完成了 Java 开发者必须手动完成的工作:被捕获并被修改的局部变量[var] 不再存储在栈上,而是存储在类[kotlin.jvm.internal.Ref.IntRef] 的一个小对象中(每种基本类型各有一个,引用类型则使用 *[Ref.ObjectRef]),该对象只有一个可变字段 *[element]。函数[main] 和 lambda 共享这个对象:在其中任何一方对[total]的每次读写,都会变成对[total.element]的读写。我们可以通过反射来验证这一点:lambda 对象的唯一字段的类型是[Ref$IntRef] (结果的第 5 行)。这与 C# 编译器对其被捕获变量所做的处理完全相同;
  • 第 31–34 行:lambda 也可以读取和修改顶层变量(第 6 行)或当前对象的属性。这里没有什么需要捕获的:顶层变量是[Lambdas06Kt] 类的静态字段;对于属性,lambda 捕获的是引用[this];
  • 第 64–67 行:函数[createCounter] 返回一个捕获并修改其局部变量[value]的 lambda。通常,局部变量在函数结束时就会消失。这里,该变量存储在由 lambda 引用的[Ref.IntRef] 对象中:只要 lambda 存在,它就比[createCounter] 存活得更久。lambda 及其所捕获的变量的组合称为“闭包”;
  • 第 37–40 行:每次调用 *[createCounter] 都会创建一个新变量 *[value],从而得到一个新计数器,与其他计数器相互独立。结果(第 7–8 行)证实了这一点;
  • 第 44–48 行:在 Kotlin 的[for] 循环中,变量[i] 是一个[val],每次迭代都是新的:每个 lambda 捕获各自的变量,因此这三个 lambda 分别打印 0、1 和 2。请注意,函数列表是通过[actions.forEach { it() }]来执行的:[it] 是一个被调用的函数;
  • 第 53–59 行:这是 Kotlin 灵活性的缺点。[while] 循环使用单个变量[k],它在每次迭代中都会被修改。这三个 lambda 捕获的是同一个变量,并在执行时打印它的值——也就是在循环结束之后,此时它等于 3:它们都打印 3(结果的第 10 行)。Java 在编译时就消除了这个陷阱;在 Kotlin 中,则需要由开发者来处理。解决办法与 Java 中相同:在循环体中为每次迭代声明一个新的[val]([val copy = k])并捕获它,或者更好的做法是使用[for] 循环。

Java 的这条规则有充分的理由:lambda 可能稍后执行,或者在另一个线程中执行(第 8 章)。如果它可以修改函数的局部变量,或者在另一个线程正在修改这些变量时读取它们,就可能导致不可预测的行为。Kotlin 采取了另一种更务实的做法:允许捕获[var] ,但是[Ref] 对象并不受并发访问的保护。因此请记住:捕获[var] 在单线程程序和立即执行的 lambda([forEach]、[filter]……)中是安全的,但一旦 lambda 可能在另一个线程中执行,就必须使用一个明确选定了线程行为的对象([AtomicInteger]、并发集合……)来显式地表达共享的可变状态。我们将在第 8 章和第 9 章回到这个主题。稍后介绍的[inline] 函数,在 lambda 被复制到调用代码中时,也会避免创建[Ref] 对象。

7.4. 内联函数与作用域函数

7.4.1. 内联函数

lambda 是一个对象。因此,把 lambda 传给高阶函数会产生开销:创建对象(不捕获任何内容的 lambda 除外,虚拟机可以复用它)、调用其[invoke] 方法、泛型接口[Int] ↔ [Integer] 所强制的[Function1]、[Function2]…… 转换,以及被捕获变量的[Ref] 对象。对于像[filter] 这样会在有时非常庞大的集合的每个元素上被调用的函数,这种开销很重要。Kotlin 通过[inline] 修饰符消除了这一开销:当函数被声明为[inline fun] 时,编译器不会生成对该函数的调用;相反,它会把该函数的代码复制到每个调用它的位置,同时也会复制传给它的 lambda 的代码。结果是不再有 lambda 对象,没有[invoke] 调用,也没有转换。接受 lambda 的标准库函数([forEach]、[filter]、[map]、[fold]、[let]、[apply]、[repeat]、[use]、[synchronized]……)几乎都是[inline]。Java 没有等价机制:它依靠虚拟机的即时编译器来产生与之相当的运行结果。

代码的插入还有第二个更明显的后果:由于 lambda 的代码被复制到调用函数中,不带标签的[return] 指令可以从那里退出调用函数。这就是非局部返回,我们曾在 *[forEach] 中遇到过,见 *[Lambdas03.kt]。有两个修饰符对 *[inline]* 起补充作用:

  • [noinline],应用于[inline] 函数的某个函数参数,指定对应的 lambda 不应被复制,而是作为普通对象传递。当函数想要保留该 lambda(把它存入列表、作为结果返回等)时,这是必需的:被复制的代码无法存储在列表中;
  • [crossinline] 要求复制 lambda,但禁止非局部返回。当[inline] 函数本身不执行该 lambda,而是在另一个上下文中执行它时——例如在它创建的[Runnable] 对象中——这是必需的:当[Runnable] 执行时,调用函数可能早已结束,而[return] 将无法再退出它。

程序[Lambdas07.kt] 演示了这些概念(该程序在 Java 课程中没有对应内容):

package lambdas07

// inline、noinline、crossinline 函数

fun main() {
    // 1 - 普通函数接收函数对象;inline 函数接收 lambda 的代码
    execute { println("lambda passed to execute, executed by: ${currentMethod()}") }
    executeInline { println("lambda passed to executeInline, executed by: ${currentMethod()}") }

    // 2 - 非局部返回只允许出现在传给 inline 函数的 lambda 中
    val numbers = listOf(3, 8, 1, 6)
    println("first even of $numbers: ${firstEven(numbers)}")

    // 3 - noinline:必须作为对象保留的 lambda
    val callbacks = mutableListOf<() -> Unit>()
    executeThenStore(callbacks, { println("executed right away") }, { println("stored callback") })
    println("${callbacks.size} stored callback, which we execute:")
    callbacks.forEach { it() }

    // 4 - crossinline:在另一个上下文中执行的 lambda
    val task = asTask { println("executed by ${Thread.currentThread().name}") }
    val thread = Thread(task, "worker")
    thread.start()
    thread.join()
}

// 调用 currentMethod 的方法的名称(从调用栈中读取)
fun currentMethod(): String = Throwable().stackTrace[1].methodName

// 普通函数:block 是 () -> Unit 类型的对象
fun execute(block: () -> Unit) {
    block()
}

// inline 函数:它的代码以及 lambda 的代码被复制到调用处
inline fun executeInline(block: () -> Unit) {
    block()
}

// 我们自己的 forEach,与库中的一样是 inline
inline fun <T> forEachElement(elements: List<T>, action: (T) -> Unit) {
    for (element in elements) action(element)
}

fun firstEven(numbers: List<Int>): Int? {
    forEachElement(numbers) {
        // 非局部返回:我们退出的是 firstEven,而不仅仅是 lambda
        if (it % 2 == 0) return it
    }
    return null
}

// immediate 被复制;stored 仍是函数对象,可以放入列表
inline fun executeThenStore(
    callbacks: MutableList<() -> Unit>,
    immediate: () -> Unit,
    noinline stored: () -> Unit,
) {
    immediate()
    callbacks.add(stored)
}

// action 在 Runnable 对象中执行,而不是在 asTask 中:那里不可能进行非局部返回
inline fun asTask(crossinline action: () -> Unit): Runnable = Runnable { action() }

结果:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=lambdas07.Lambdas07Kt
lambda passed to execute, executed by: main$lambda$0
lambda passed to executeInline, executed by: main
first even of [3, 8, 1, 6]: 8
executed right away
1 stored callback, which we execute:
stored callback
executed by worker

注释:

  • 第 28 行:函数[currentMethod] 返回调用它的方法的名称。为此,它创建一个[Throwable] 对象,该对象会保存其创建时的执行栈,然后读取该栈的第二个元素(第一个元素是[currentMethod] 本身)。我们用它来确定 lambda 的代码是在哪里执行的;
  • 第 31–36 行:两个相同的函数,一个是普通函数,另一个被声明为[inline];
  • 第 7 行:lambda 被传给普通函数[execute]。编译器把它变成类[Lambdas07Kt] 的一个私有方法的方法体——这里名为[main$lambda$0]——并创建一个调用它的类型为[() -> Unit] 的对象。确实是[main$lambda$0] 在执行(结果的第 1 行);
  • 第 8 行:lambda 被传给[inline] [executeInline] 函数。编译器把[executeInline] 的函数体和 lambda 的函数体复制到了[main]中:lambda 的[println] 直接在[main] 方法中执行(结果的第 2 行)。没有创建任何函数对象;
  • 第 41–50 行:[forEachElement] 是我们自己版本的[forEach],与原版一样也是[inline]。在[firstEven]中,lambda 里的[return it] 语句是非局部返回:它通过返回找到的第一个偶数来退出[firstEven] 函数(结果的第 3 行),循环就在这里停止。对于像[execute] 这样的普通函数,编译器会拒绝这样的[return] (['return' is prohibited here]):lambda 会是一个独立的对象,可能在[firstEven] 结束之后才被执行;
  • 第 54–60 行:一个接受两个 lambda 的[inline] 函数:它执行第一个 lambda,并把第二个存入列表以便稍后执行。第二个参数必须被声明为[noinline]:没有这个修饰符,编译器会拒绝把 lambda 存入列表([illegal usage of inline parameter 'stored: () -> Unit'. Add 'noinline' modifier to the parameter declaration.])。第 16–18 行使用了它(输出的第 4–6 行);
  • 第 64 行:函数[asTask] 创建一个将执行 lambda[Runnable] 的对象(SAM 转换)[action]。该参数必须被声明为[crossinline]:没有这个修饰符,编译器会拒绝它([cannot inline 'action: () -> Unit' here: it might contain non-local returns. Add 'crossinline' modifier to parameter declaration 'action: () -> Unit'.])。第 21–24 行执行所得到的[Runnable] ,在名为[worker] 的线程中(线程将在第 8 章介绍),结果的第 7 行证实了这一点。

你不应该对任意函数都使用[inline] :该修饰符只对接受函数参数的函数有用,而且它会增加生成代码的大小(实际上,对于没有函数参数的[inline] 函数,编译器会发出警告)。最后,它还有第三种用途,将在第 4 章讨论:只有[inline] 函数才能拥有[reified] 类型的参数([inline fun <reified T> …]),其类型在运行时仍然是已知的,因为代码被复制到了该类型已知的位置。

7.4.2. 作用域函数

Kotlin 标准库提供了五个小巧而被广泛使用的函数——[inline]——称为“作用域函数”:[let]、[run]、[with]、[apply]和[also]。它们几乎什么也不做:每个函数都是在一个对象上执行一个 lambda。它们在两个方面有所不同:

  • lambda 引用该对象的方式:要么作为其参数[it] (lambda 的类型为[(T) -> R]),要么作为其接收者[this],此时它可以省略(该 lambda 是带接收者的 lambda,类型为[T.() -> R];参见[Lambdas01.kt]);
  • 也就是函数所返回的内容:要么是 lambda 的结果,要么是对象本身。
函数
所指代的对象
返回值
典型用法
[let]
[it]
lambda 的结果
转换一个值;与[?.let]配合,处理非空值
[run]
[this]
lambda 的结果
根据对象的属性计算结果
[with(object)]
[this]
lambda 的结果
类似于[run],只是对象作为参数传入
[apply]
[this]
对象本身
配置新创建的对象
[also]
[it]
对象本身
附加处理(日志记录、缓存等),而不改变调用链

程序[Lambdas08.kt] 使用了它们(它在 Java 课程中没有对应内容):

package lambdas08

// 作用域函数:let、run、with、apply、also(以及 takeIf)

fun main() {
    // 1 - apply:配置对象(this)并返回该对象
    val paul = Person("Paul").apply {
        age = 32
        city = "Angers"
    }
    println("apply: $paul")

    // 2 - also:对对象(it)做额外处理,并返回该对象
    val persons = mutableListOf<Person>()
    val melanie = Person("Mélanie", 25).also { persons.add(it) }
    println("also: $melanie, persons=$persons")

    // 3 - let:将对象(it)转换为一个结果;常与 ?. 搭配使用
    val length = paul.name.let { it.length * 2 }
    println("let: length=$length")
    for (city in listOf("Tours", null)) {
        val message = city?.let { "lives in ${it.uppercase()}" } ?: "unknown city"
        println("let and ?.: $message")
    }

    // 4 - run:对对象(this)进行计算,并返回一个结果
    val description = paul.run { "$name, $age years old, lives in $city" }
    println("run: $description")

    // 5 - with:类似 run,但对象作为参数传入
    val summary = with(StringBuilder()) {
        append("Persons: ")
        append(persons.joinToString { it.name })
        toString()
    }
    println("with: $summary")

    // 6 - takeIf:若对象满足谓词则返回该对象,否则返回 null
    for (age in listOf(15, 40)) {
        val adult = Person("Jo", age).takeIf { it.age >= 18 }
        println("takeIf: ${adult ?: "minor"}")
    }
}

class Person(val name: String, var age: Int = 0) {
    var city: String? = null

    override fun toString() = "Person(name=$name, age=$age, city=$city)"
}

结果:

> gradlew -q run -Pmain=lambdas08.Lambdas08Kt
apply: Person(name=Paul, age=32, city=Angers)
also: Person(name=Mélanie, age=25, city=null), persons=[Person(name=Mélanie, age=25, city=null)]
let: length=8
let and ?.: lives in TOURS
let and ?.: unknown city
run: Paul, 32 years old, lives in Angers
with: Persons: Mélanie
takeIf: minor
takeIf: Person(name=Jo, age=40, city=null)

注释:

  • 第 45–48 行:一个带有可变属性的普通[Person]类;
  • 第 7–9 行:[apply] 以该对象作为接收者执行 lambda:在 lambda 内,[age = 32] 指的是[this.age = 32]。然后它返回该对象,并将其赋给[paul]。这样就在一个表达式中完成了对象的创建和配置。它的签名说明了这一机制:[inline fun <T> T.apply(block: T.() -> Unit): T];
  • 第 15 行:[also] 以该对象作为参数[it]执行 lambda,然后返回该对象。它用于产生副作用(此处是向列表中添加元素),而无需引入中间变量;
  • 第 19 行:[let] 以该对象作为参数[it] 执行 lambda,并返回 lambda 的结果:这是一种转换;
  • 第 21–23 行:[let]最常见的用法,如第 3 章所见:[city?.let { … }] 只有当[city] 不为[null]时才执行 lambda,并且在 lambda 内,[it] 的类型是[String] 而不是[String?]。如果[city] 等于[null],则该表达式等于[null],此时 Elvis 运算符[?:] 提供默认值;
  • 第 27 行:[run] 以该对象作为接收者执行 lambda,并返回 lambda 的结果:它直接使用属性 [name]、[age] 和 [city] (属于 [paul]);
  • 第 31–34 行:[with] 的作用与[run]相同,但对象是作为第一个参数传给它的,lambda 位于第二位,在圆括号之外。在 lambda 内调用的所有方法([append]、[toString])都是[StringBuilder]的方法。第 5 章中的函数[buildString] 就是按这种模型构建的;
  • 第 39–41 行:[takeIf] 不是作用域函数,但它的使用方式相同:如果对象满足谓词,它就返回该对象,否则返回[null] 。它可以与[?:]、[?.let]……自然地组合([takeUnless] 则相反)。

这些函数使代码更紧凑,但不应被过度使用:多个嵌套的作用域函数,各自带有自己的[it] 或[this],很快就会使代码难以阅读。一个命名良好的局部变量往往更可取。

7.5. 函数类型、函数式接口,还是接口?

在许多语言中,“作为参数传递的函数”这一概念(C 中的函数指针、C# 中的委托)与接口的概念是不同的,人们可能会想该选哪一个。在 Java 中,这个问题的提法不同,因为这两个概念是同一回事:lambda就是接口的一个实例。Kotlin 介于两者之间:它有函数类型,在语法上与接口不同,但对虚拟机来说就是接口;它还有可以用 lambda 实现的函数式接口([fun interface])。让我们来看示例[Lambdas09.kt],它与[Lambdas02.kt]类似:

package lambdas09

// 一个函数类型的参数

fun main() {
    // 执行 add 函数
    println(execute(2, 3, ::add))
    // 执行 subtract 函数
    println(execute(2, 3, ::subtract))
    // 执行一个形状匹配的 Java 库方法
    println(execute(2, 3, Math::max))
    // 执行一个 lambda:无需具名函数
    println(execute(2, 3) { n1, n2 -> n1 * n2 })
}

// 执行作为参数接收的操作
// (放在最后,这样 lambda 就可以写在括号之外传入)
fun execute(n1: Int, n2: Int, op: (Int, Int) -> Int): Int = op(n1, n2)

// 两个形状为 (Int, Int) -> Int 的函数
fun add(n1: Int, n2: Int): Int {
    println("add($n1,$n2)")
    return n1 + n2
}

fun subtract(n1: Int, n2: Int): Int {
    println("subtract($n1,$n2)")
    return n1 - n2
}

结果:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=lambdas09.Lambdas09Kt
add(2,3)
5
subtract(2,3)
-1
3
6

在第 18 行,函数[execute] 期望一个类型为[(Int, Int) -> Int]的参数。这使得可以向它传入不同的函数:我们自己的高层函数[add] 和 [subtract] (第 7 行和第 9 行),一个形式正确的 Java 库方法(第 11 行:在[Math.max]的重载中,编译器选择[int max(int a, int b)],Kotlin 将其视为 ***[max(a: Int, b: Int): Int]***),甚至还可以传入 lambda(第 13 行):无需编写乘法函数。函数参数被放在最后,以便 lambda 可以写在圆括号之外:这是整个 Kotlin 库的约定,在你自己的函数中遵循它是个好主意。

使用[fun interface],我们看到的是第 4 章介绍的接口多态:程序[Lambdas10.kt] 通过用类来实现同一个接口来演示这一点:

package lambdas10

// 实现函数式接口或函数类型的类

fun main() {
    // 执行 Add 操作
    println(execute(Add(), 2, 3))
    // 执行 Subtract 操作
    println(execute(Subtract(), 2, 3))
    // 同一个 execute 函数仍然接受 lambda
    println(execute({ n1, n2 -> n1 * n2 }, 2, 3))
    // 含有两个抽象方法的接口不再接受 lambda:需要使用类
    val division = object : NamedOperation {
        override fun calculate(n1: Int, n2: Int) = n1 / n2

        override val name = "integer division"
    }
    println("${division.name}: ${division.calculate(7, 2)}")
    // 类也可以实现函数类型
    val modulo = Modulo()
    println("modulo(7, 2)=${modulo(7, 2)}, applyFunction(modulo)=${applyFunction(modulo, 7, 3)}")
}

// 执行 Operation 接口的唯一方法
fun execute(op: Operation, n1: Int, n2: Int): Int = op.calculate(n1, n2)

// 执行类型为 (Int, Int) -> Int 的函数
fun applyFunction(f: (Int, Int) -> Int, n1: Int, n2: Int): Int = f(n1, n2)

// 函数式接口 Operation
fun interface Operation {
    fun calculate(n1: Int, n2: Int): Int
}

// 一个非函数式的接口:含有一个抽象方法和一个抽象属性
interface NamedOperation : Operation {
    val name: String
}

// 类 Add
class Add : Operation {
    override fun calculate(n1: Int, n2: Int): Int {
        println("Add($n1,$n2)")
        return n1 + n2
    }
}

// 类 Subtract
class Subtract : Operation {
    override fun calculate(n1: Int, n2: Int): Int {
        println("Subtract($n1,$n2)")
        return n1 - n2
    }
}

// 实现函数类型 (Int, Int) -> Int 的类
class Modulo : (Int, Int) -> Int {
    override fun invoke(n1: Int, n2: Int): Int = n1 % n2
}

结果:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=lambdas10.Lambdas10Kt
Add(2,3)
5
Subtract(2,3)
-1
6
integer division: 3
modulo(7, 2)=1, applyFunction(modulo)=1

注释:

  • 第 31–32 行:函数式接口[Operation] 定义了方法[calculate];
  • 第 41–49 行:类[Add] 和 [Subtract] 实现了接口[Operation];
  • 第 25 行:函数[execute],其第一个参数的类型由接口[Operation]定义。它依次接收类[Add]的一个实例、类[Subtract] 的一个实例(第 7 行和第 9 行),然后是一个 lambda(第 11 行)。对于 lambda,由于它是调用实参,因此会自动执行从 SAM 到 *[Operation] 的转换。对于[execute]而言,这三个对象的类型相同:都是实现了[Operation]*的对象;
  • 第 36–37 行:[NamedOperation] 接口继承了[calculate] 方法,并添加了一个抽象属性[name]。它不是函数式的(实际上,它不能被声明为[fun interface]):它不能再用 lambda 来实现;需要一个类——在这里是一个匿名对象(第 13–16 行);
  • 第 57–58 行:反过来也成立:类可以实现函数类型,因为函数类型是接口。这样它的实例就可以像函数一样被调用([modulo(7, 2)]),并且可以传给任何期望函数的地方([applyFunction(modulo, 7, 3)],第 21 行)。

这两个示例表明,在 Kotlin 中,正如在 Java 中一样,期望一种行为的函数既接受为此目的编写的类的对象,也接受引用和 lambda。还有两个问题。第一个是 Kotlin 特有的:对于函数参数,是必须使用函数类型,还是[fun interface] 就足够了?

  • 函数类型是默认的选择。它不需要声明,像函数一样被调用,直接接受 lambda 和引用,并且能受益于[inline] 函数。当它很长时,可以用[typealias] 给它起个名字;
  • 当你想要一个真正独立的类型(不会与另一个形式相同的函数混淆)、一个具有描述性名称的方法、带方法体的额外方法,或者一个同样面向 Java 调用方的 API 时,使用“fun”接口是合理的:对 Java 而言,[fun interface] 是一个普通的函数式接口,可以配合其 lambda 使用,而 Kotlin 的函数类型在 Java 看来是一个[Function2<Integer, Integer, Integer>] ,其[invoke] 方法必须返回一个对象(对于“无返回值”的函数,则返回[Unit] )。

第二个问题与 Java 中相同:接口应该只有一个方法,还是有多个方法?

  • 函数、函数类型或单方法接口使用起来更灵活:任何形式正确的现有函数都可以使用,而 lambda 甚至允许你直接在调用处编写该函数。无需编写类。这种灵活性解释了为什么现代库(集合、第 9 章中的协程、Spring)大量使用函数参数;
  • 一旦要实现的行为涉及若干相互关联的操作(如上文的[calculate] 和 [name]),或者需要自己的状态和标识,具有多个成员的接口就重新占据优势。

第 6 章中 [ITaxDao] 接口所在的[dao] 层就是这种情况:尽管它只有一个成员——属性[val taxBrackets: List<TaxBracket>]——但它的实现具有状态(读取的税率档、文件名),由依赖注入容器创建,并在应用程序中代表一个命名清晰的角色。[() -> List<TaxBracket>] 在技术上本来也足够了,但描述性要差得多。因此,我们把函数类型留给简短的一次性行为(一个条件、一次转换、一个动作),而把“业务”接口用于应用程序的角色,无论它们有多少个成员。

7.6. 事件处理

7.6.1. 观察者模式

作为参数传递的函数用于建立事件机制。与 Java 一样,Kotlin 没有专门用于事件的关键字(C# 有自己的关键字[event]):它使用 Java 早在 1.1 版就为图形组件和 JavaBeans 确立的约定,称为“监听器模型”。[C1] 类想要发出 [Xxx] 事件信号时,按如下步骤进行:

  • [XxxEvent] 类封装有关事件的信息,包括触发事件的对象,称为源。在 Java 中,约定它派生自[java.util.EventObject],后者存储事件源;在 Kotlin 中,一个带只读属性的普通类就足够了,我们也将这样做;
  • 监听器类型定义事件发生时将被调用的函数的形式。在 Java 中,这是一个名为[XxxListener]的接口;在 Kotlin 中,它通常是一个简单的函数类型[(XxxEvent) -> Unit],通过[typealias]命名:监听器将是一个 lambda 或函数引用;
  • [C1] 类管理一个函数列表,并提供两个公共方法用于向其注册和注销:[addXxxListener(listener)] 和[removeXxxListener(listener)];
  • 当[c1] 作为[C1] 的实例想要发出事件信号时,它创建一个 [XxxEvent] 对象,并调用每个已注册的监听器,把这个对象传给它们。按照约定,这种通知由受保护方法[fireXxx(e: XxxEvent)] (“fire”,即触发)处理,派生类可以重写它以修改事件的发布方式;
  • 如果对象[c2] 想要收到来自对象[Xxx] 的事件[c1]的通知,它就使用[c1.addXxxListener(...)]订阅。当它不再希望被通知时,可以通过[c1.removeXxxListener(...)] 取消订阅。由于[c1] 管理的是一个列表,不同的对象可以订阅同一个事件的通知。

在这个场景中,我们有:

  • 一个发出(也称为“发布”或“发射”)事件的类;
  • 接收此事件通知的对象。它们被称为订阅或注册该事件:它们就是监听器,或事件处理程序;
  • 一种监听器类型,用于定义将收到事件通知的函数的形式。

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

7.6.2. 示例:温度过高

请看下面的示例:

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

该程序分为[lambdas11] 包中的三个文件。首先是文件[Emitter.kt],它包含事件类、监听器类型和类 [Emitter]:

package lambdas11

import java.time.LocalTime
import java.util.concurrent.CopyOnWriteArrayList

// 事件所携带的信息
class TemperatureTooHighEvent(
    // 触发该事件的发射器
    val source: Emitter,
    // 事件发生时的温度
    val temperature: Double,
) {
    // 事件发生的时间
    val time: LocalTime = LocalTime.now()
}

// 事件监听器的形状:一个简单的函数类型
typealias TemperatureTooHighListener = (TemperatureTooHighEvent) -> Unit

// 发出事件信号的类
open class Emitter(val name: String) {
    companion object {
        // 触发事件的阈值
        const val THRESHOLD = 19.0
    }

    // 已注册的监听器:一个函数列表
    private val listeners = CopyOnWriteArrayList<TemperatureTooHighListener>()

    // 被观察的温度:写入该属性可以触发事件
    var temperature = 0.0
        set(value) {
            field = value
            if (value > THRESHOLD) {
                // 向监听器发出事件信号
                fireTemperatureTooHigh(TemperatureTooHighEvent(this, value))
            }
        }

    // 注册监听器
    fun addTemperatureTooHighListener(listener: TemperatureTooHighListener) {
        listeners.add(listener)
    }

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

    // 向所有已注册的监听器通知事件
    protected open fun fireTemperatureTooHigh(e: TemperatureTooHighEvent) {
        for (listener in listeners) {
            listener(e)
        }
    }
}

注释:

  • 第 7–14 行:[TemperatureTooHighEvent] 类存储事件源,其类型为[Emitter],以及触发事件的温度。我们添加了事件时间[time],它在对象创建时初始化。所有属性的类型都是[val]:监听器不应该能够为后续的监听器修改事件信息。我们没有像 Java 中那样让该类派生自[EventObject] :这在此处毫无用处,并且会迫使我们——为了让事件源的类型是[Emitter] 而不是[Any]——重新定义[getSource] 方法;
  • 第 18 行:监听器的类型。监听器是一个以事件对象为参数且不返回任何值的函数。在 Java 要求一个派生自 *[TemperatureTooHighListener]* 的接口 *[EventListener]* 的地方,Kotlin 只是使用一个函数类型别名。我们同样可以声明一个 ***[fun interface TemperatureTooHighListener]***:如果监听器要用 Java 编写,这将是正确的选择;
  • 第 24 行:触发[TemperatureTooHigh] 事件的温度阈值,是伴生对象的一个常量;
  • 第 21 行:发射者有一个用于标识的名称。该类被声明为[open],以便派生类可以重新定义[fireTemperatureTooHigh] 方法;
  • 第 28 行:已注册监听器的列表,即函数列表。它是来自[CopyOnWriteArrayList] 包[java.util.concurrent]的一个列表,每当它被修改时,都会把其内容复制到一个新数组中。因此,正在进行的迭代会继续在旧数组上进行,即使列表在此期间被修改。稍后我们将看到为什么这在这里至关重要。这个列表是监听器列表的标准类型:每个事件都会遍历该列表,但它很少被修改;
  • 第 31–36 行:属性[temperature] 有一个自定义访问器[set] (第 4 章):它把新值存入隐藏字段[field],然后在超过阈值时发出事件信号。发布由[fireTemperatureTooHigh] 方法处理,传给它的是一个[TemperatureTooHighEvent] 对象;该对象来自发射者本身([this]),并包含超过阈值的温度。在 Java 要求一个名为[setTemperature]的方法的地方,类的使用者只需写[e1.temperature = 21.0];
  • 第 41–42 行:注册监听器就是把它添加到列表中。参数类型不可为空:编译器会拒绝任何类型为[null]的监听器,而 Java 必须在运行时通过[Objects.requireNonNull]来拒绝;
  • 第 46–47 行:注销就是从列表中移除监听器。方法[remove] 使用[equals]来查找要移除的对象:因此,必须向它传入与已注册的对象相同的对象;
  • 第 51–53 行:通知按注册顺序,把每个已注册的监听器作为函数调用:[listener(e)]。如果没有监听器,循环什么也不做:无需处理任何特殊情况。

下面是文件[Subscriber.kt]:

package lambdas11

// 一个注册为事件监听器的类
class Subscriber(
    // 订阅者的名称
    private val name: String,
    // 可接受的最大警报数
    private val nbMaxAlerts: Int,
) {
    // 已收到的警报数
    private var nbAlerts = 0

    // 向发射器注册
    fun subscribe(emitter: Emitter) {
        emitter.addTemperatureTooHighListener(::onTemperatureTooHigh)
    }

    // 注销:对同一对象的同一方法的新引用与原引用相等
    fun unsubscribe(emitter: Emitter) {
        emitter.removeTemperatureTooHighListener(::onTemperatureTooHigh)
    }

    // TemperatureTooHigh 事件的处理程序
    private fun onTemperatureTooHigh(e: TemperatureTooHighEvent) {
        val emitter = e.source
        val temperature = "%.1f".format(e.temperature)
        println("Subscriber [$name]: the source [${emitter.name}] " +
            "signaled a temperature that is too high: [$temperature]")
        // 超过 nbMaxAlerts 次警报后,订阅者注销
        nbAlerts++
        if (nbAlerts == nbMaxAlerts) {
            unsubscribe(emitter)
            println("Subscriber [$name]: unsubscribed after $nbAlerts alert(s)")
        }
    }
}

注释:

  • 第 4–11 行:每个订阅者由名称标识,并被指定它所接受的最大警报数([nbMaxAlerts])。它对收到的警报进行计数([nbAlerts]);
  • 第 14–15 行:向发射者注册。监听器是一个绑定引用[::onTemperatureTooHigh],即 [this::onTemperatureTooHigh]:这个订阅者的方法 [onTemperatureTooHigh];
  • 第 19–20 行:取消订阅时,把一个新的引用 [::onTemperatureTooHigh] 传给 [removeTemperatureTooHighListener]。在 Java 中,这会是一个典型的错误:对 ***[this::onTemperatureTooHigh] 求值两次会产生两个被 *[equals] 认为不同的对象,取消订阅将不会移除任何东西,也不会有任何错误消息;监听器必须只创建一次并存储在字段中。我们在[Lambdas04.kt] 中已经看到,在 Kotlin 中,指向同一对象的同一函数的两个引用是相等的:因此[remove] 能找到已注册的监听器——并且只找到该监听器——因为其他订阅者的引用绑定到的是其他对象。对于 lambda 则不然:[{ e -> onTemperatureTooHigh(e) }]**写两次,会得到两个不同的对象;
  • 第 24 行:事件处理程序。它具有由类型[TemperatureTooHighListener]规定的形式。它是私有的:只有订阅者才能把它注册到发射者。另一种做法是让监听器类型由[Subscriber] 类本身实现([class Subscriber : TemperatureTooHighListener],带有一个[invoke] 方法),并用[this]进行注册。这种做法的缺点是使[invoke] 方法成为公共方法,任何人都可以调用它;
  • 第 25 行:事件源的类型直接就是[Emitter];
  • 第 26–28 行:处理程序显示订阅者的名称、报告该事件的发射者的名称以及触发该事件的温度。[%.1f] 格式按照本机的本地约定显示保留一位小数的实数(Kotlin 函数 [format] 使用这些约定;此处为小数点)。字符串被分成两部分,用[+] 连接,以便该行能放进页面;
  • 第 30–33 行:在收到[nbMaxAlerts] 次警报之后,订阅者取消对发射者的订阅。它是在事件通知期间从自己的处理程序中这样做的——也就是在[fireTemperatureTooHigh] 方法遍历监听器列表时。由于有[CopyOnWriteArrayList],这样做是安全的:[remove] 会创建一个新数组,但当前的迭代仍在旧数组上继续。

最后是主程序[Lambdas11.kt]:

package lambdas11

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

fun main() {
    // 创建一个事件发射器
    val e1 = Emitter("e")
    // 创建两个向 e1 注册的订阅者
    val subscribers = listOf(Subscriber("s0", 3), Subscriber("s1", 1))
    for (subscriber in subscribers) {
        subscriber.subscribe(e1)
    }
    // 第三个监听器:一个 lambda
    e1.addTemperatureTooHighListener { e ->
        println("Log: %.1f °C at %tT".format(e.temperature, e.time))
    }

    // 从键盘读取温度
    while (true) {
        print("Temperature (nothing to stop): ")
        // 输入结束?(若标准输入已关闭,readlnOrNull 返回 null)
        val input = readlnOrNull()
        if (input.isNullOrBlank()) {
            break
        }
        // 接受使用逗号作为小数点
        val temperature = input.trim().replace(',', '.').toDoubleOrNull()
        if (temperature == null) {
            // 报告错误
            println("Incorrect temperature")
        } else {
            // 温度正确:将其存入发射器
            e1.temperature = temperature
        }
    }
}

结果(标准输入通过重定向提供;我们在程序读取输入的提示之后重新插入了这些输入):

> gradlew -q run -Pmain=lambdas11.Lambdas11Kt
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] signaled a temperature that is too high: [21.0]
Subscriber [s1]: the source [e] signaled a temperature that is too high: [21.0]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21.0 °C at 12:33:37
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22,5
Subscriber [s0]: the source [e] signaled a temperature that is too high: [22.5]
Log: 22.5 °C at 12:33:37
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] signaled a temperature that is too high: [25.0]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25.0 °C at 12:33:37
Temperature (nothing to stop): 30
Log: 30.0 °C at 12:33:37
Temperature (nothing to stop):

注释:

  • 第 7 行:创建发射者;
  • 第 9–11 行:创建两个订阅者,[s0] (最多 3 次警报)和[s1] (1 次警报),它们被注册到发射者;
  • 第 14–15 行:第三个监听器,是一个放在圆括号之外传入的 lambda,起日志的作用。参数[e] 的类型是从[addTemperatureTooHighListener]的参数类型推断出来的。格式[%tT] 以[HH:mm:ss]的形式显示时间。这个 lambda 无法被注销:必须事先把它存储在变量中,才能把同一个对象传给[removeTemperatureTooHighListener]。因此,直接写在注册调用中的 lambda 只适用于只要发射者存在就一直保持注册的监听器;
  • 第 19–33 行:通过键盘输入温度的循环。[readlnOrNull()] 读取一行;如果标准输入已关闭,它返回[null] ,这种情况通过[isNullOrBlank]被当作空输入处理(第 23 行)。在这个测试之后,编译器知道[input] 不是[null] (智能转换);
  • 第 27 行:[toDoubleOrNull] 只接受小数点。为了让法国用户可以输入[22,5],逗号被替换为句点。如果输入不是数字,[toDoubleOrNull] 返回[null]:无需像 Java 版本使用[Double.parseDouble]时那样捕获异常;
  • 第 33 行:如果输入的温度正确,它就被赋给发射者[temperature] 的属性[e1],其访问器[set] 在温度高于 19 °C 时发出事件[TemperatureTooHigh] 的信号。

结果显示如下(每次运行时的时间会有所不同):

  • 第 1 行:17 °C 没有超过阈值:没有事件;
  • 第 2–6 行:21 °C 触发了事件。三个监听器按它们注册的顺序收到通知。[s1]只接受一次警报,因此立即取消订阅,但这并不妨碍在它之后注册的日志收到通知;
  • 第 9–11 行:[s1] 不再收到通知:通过新引用取消订阅按预期生效;
  • 第 12–15 行:[s0] 收到第三次警报,并依次取消订阅;
  • 第 16–17 行:只剩下日志。

如果只用一个普通的 [ArrayList] 而不用[CopyOnWriteArrayList] ,放在[Emitter] 类中,会发生什么?我们测试过:当[s1] 在列表处理过程中取消订阅时,后续的项会被跳过,处理立即停止。日志没有收到温度 21 和 25 的通知,而且没有任何错误消息。在其他情况下,循环会抛出 [ConcurrentModificationException]。因此,监听器列表必须始终支持在被迭代的同时发生变化:[CopyOnWriteArrayList] 正是为此而设计的,并且它还支持其他线程进行的订阅和取消订阅(第 8 章)。

7.6.3. 属性变更事件

最常见的一类事件发生在对象的属性值发生变化时:另一个对象(图形用户界面、缓存、日志)希望收到这一变化的通知。Kotlin 和 Java 库为这种场景提供了两种互补的工具:

  • Kotlin 的委托属性。声明为[var p: T by delegate] 的属性把对其值的读写委托给另一个对象,即委托。标准库提供了其中的几个,例如[by lazy { … }],它在第一次访问时计算属性的值。对象[kotlin.properties.Delegates] 提供了两个接受 lambda 的委托:[Delegates.observable(initialValue) { property, old, new -> … }] 在每次写入属性之后执行该 lambda;[Delegates.vetoable(initialValue) { property, old, new -> … }] 在写入之前执行它,并且只有当 lambda 返回[true]时才接受新值。参数[property] 是对该属性的引用([KProperty]),可通过[property.name]获得它的名称;
  • Java 类[java.beans.PropertyChangeSupport],它为我们管理监听器列表。监听器实现函数式接口[PropertyChangeListener],其方法[void propertyChange(PropertyChangeEvent evt)] 接收一个事件,其中包含事件源、属性名称及其旧值和新值。

委托[observable] 知道属性何时发生变化,而[PropertyChangeSupport] 知道要通知谁:程序[Lambdas12.kt] 把它们连接在一起:

package lambdas12

import java.beans.PropertyChangeListener
import java.beans.PropertyChangeSupport
import kotlin.properties.Delegates
import kotlin.properties.ReadWriteProperty

// 属性变更事件:Delegates.observable、vetoable 和 PropertyChangeSupport

fun main() {
    val thermometer = Thermometer("living room")
    // 所有属性的监听器
    val log = PropertyChangeListener { e ->
        val source = e.source as Thermometer
        println("Log: ${source.name}.${e.propertyName} : ${e.oldValue} -> ${e.newValue}")
    }
    thermometer.addPropertyChangeListener(log)
    // 仅 temperature 属性的监听器
    thermometer.addPropertyChangeListener("temperature") { e ->
        if (e.newValue as Double > 19) {
            println("Alert: temperature too high")
        }
    }

    thermometer.temperature = 18.0
    thermometer.temperature = 21.5
    // 值相同:不触发事件
    thermometer.temperature = 21.5
    thermometer.name = "lounge"
    // 注销日志监听器
    thermometer.removePropertyChangeListener(log)
    thermometer.temperature = 22.0
    println("remaining listeners: ${thermometer.nbListeners}")

    // 一个可以拒绝新值的属性
    for (value in listOf(21.0, 45.0)) {
        thermometer.setpoint = value
        println("requested setpoint: $value, retained setpoint: ${thermometer.setpoint}")
    }
}

// 一个其属性会发出变更信号的类
class Thermometer(name: String) {
    // 监听器管理委托给一个 PropertyChangeSupport 对象
    private val changes = PropertyChangeSupport(this)

    // 一个可观察属性:每次写入后都会发出变更信号
    private fun <T> observable(initialValue: T): ReadWriteProperty<Any?, T> =
        Delegates.observable(initialValue) { property, old, new ->
            changes.firePropertyChange(property.name, old, new)
        }

    var name: String by observable(name)
    var temperature: Double by observable(0.0)

    // 一个拒绝区间 [5, 30] 之外的值的属性
    var setpoint: Double by Delegates.vetoable(20.0) { _, _, new -> new in 5.0..30.0 }

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

    fun addPropertyChangeListener(property: String, listener: PropertyChangeListener) {
        changes.addPropertyChangeListener(property, listener)
    }

    fun removePropertyChangeListener(listener: PropertyChangeListener) {
        changes.removePropertyChangeListener(listener)
    }

    val nbListeners: Int
        get() = changes.propertyChangeListeners.size
}

结果:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=lambdas12.Lambdas12Kt
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
requested setpoint: 21.0, retained setpoint: 21.0
requested setpoint: 45.0, retained setpoint: 21.0

注释:

  • 第 3–4 行:[java.beans] 包属于 JDK 的[java.desktop] 模块,而不属于[java.base] 模块。由于我们的程序不是 Java 模块,JDK 中的所有类对它都是可访问的:我们只需导入它们;
  • 第 45 行:[Thermometer] 类把对其监听器的管理委托给一个[PropertyChangeSupport] 对象,该对象是使用事件源([this])构造的。第 60–69 行的方法只是把订阅和取消订阅事件传递给它,而[nbListeners] 属性(第 72–73 行)返回已注册监听器的数量;
  • 第 48–50 行:一个小型泛型函数,它创建一个[Delegates.observable] 委托,其 lambda 把每次变更传给[firePropertyChange],同时附带属性名称([property.name])、旧值和新值。它返回一个 *[ReadWriteProperty<Any?, T>]*,即可变属性委托的接口。与方法一样,写在类内部的 lambda 可以访问对象的私有属性,这里是 [changes];
  • 第 53–54 行:该类的两个可观察属性。关键字[by] 把它们的管理委托给由我们的函数[observable]创建的委托。与 Java 版本相比,在 Java 版本中每个 setter 都必须存储旧值、保存新值,并以字符串形式写出属性名称来调用 *[firePropertyChange] ,而 Kotlin 版本每个属性只需一行,并且属性名称不可能拼错。委托在每次写入时都会执行 lambda,即使值没有改变;不过,[firePropertyChange]* 只有在两个值不同时才通知监听器:因此第 28 行不改变值的写入不会产生任何输出;
  • 第 13–17 行:第一个观察者,是一个被转换为[PropertyChangeListener] 并存储在变量中的 lambda,以便可以取消订阅(第 31 行)。它订阅了该对象的所有属性。[e.source] (即[e.getSource()],在 Kotlin 中被视为属性)的类型是[Any],必须用[as]进行类型转换。这些值是对象:[Double] 对象使用它们的[toString] 方法来显示,该方法使用小数点;
  • 第 19–21 行:第二个监听器,只为属性[temperature]注册。lambda 被移到圆括号之外,并被转换为[PropertyChangeListener] (SAM 转换)。当温度超过 19 °C 时,它会触发警报。[e.newValue as Double] 把类型为[Any?]的新值进行转换;
  • 第 25–33 行:属性变更通过简单的赋值进行。名称变更(第 29 行)只报告给日志。在结果的第 4 行,日志显示新的源名称[lounge]:事件是在变更之后报告的。取消订阅日志之后,只显示警报,并且只剩下一个监听器;
  • 第 57 行:属性[setpoint] 使用委托[vetoable]。它的 lambda 在每次写入操作之前被调用,只有当新值介于 5 和 30 °C 之间时才接受它([new in 5.0..30.0]);它的前两个参数在这里不需要,用[_]表示。第 36–38 行:值 21 被接受,而值 45 被拒绝;属性保留其先前的值(结果的第 7–8 行)。JavaBeans 实例有一个等价的机制,即使用[VetoableChangeSupport] 以及抛出 [PropertyVetoException]的监听器。

这样,无需编写事件类或监听器类型,我们就得到了一个完整的机制。[PropertyChangeSupport] 是 Swing GUI 组件和 JavaBeans 所使用的机制;JavaFX 对可观察属性有自己的、非常相似的机制。另一方面,当只有一个观察者,并且在编写类时就已知道它时,委托[observable] 和[vetoable]本身就足够了。最后请注意,对于异步事件流,Kotlin 提供了 kotlinx.coroutines 库中的[Flow] ,我们将在第 9 章介绍它(尤其是[StateFlow],它的作用相当于可观察属性)。

7.7. lambda、集合与序列

在第 5 章中,我们通过向集合的函数式操作([filter]、[map]、[sortedBy]……)和序列传入 lambda 来使用它们。现在我们知道这些参数是什么了:函数[filter] 在标准库中是这样声明的:[inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>]。

它是一个扩展函数,[inline],其参数是函数类型:任何接受一个元素并返回 Boolean 的函数或 lambda 都适用。同样,[map] 期望一个[(T) -> R],[sortedBy] 期望一个[(T) -> R?],并且[R] 是可比较的,[forEach] 对应于[(T) -> Unit],[reduce] 对应于 [(S, T) -> S]……为了充分理解它们的工作原理,让我们编写自己的过滤和转换操作。下面是程序[Lambdas13.kt]:

package lambdas13

// lambda、集合和序列

fun main() {
    val numbers = listOf(3, 8, 1, 6, 5, 4, 9, 2)

    // 1 - filter 和 map 需要 (T) -> Boolean 和 (T) -> R 形式的函数
    val isEven: (Int) -> Boolean = { it % 2 == 0 }
    val square: (Int) -> Int = { it * it }
    println("collections: ${numbers.filter(isEven).map(square)}")
    // Java Stream API 仍然可用:lambda 会被转换为 Predicate 和 Function
    println("Stream: ${numbers.stream().filter { it % 2 == 0 }.map { it * it }.toList()}")

    // 2 - 我们自己的过滤函数,先用 lambda 调用,再用引用调用
    println("filterBy(n > 4): ${numbers.filterBy { it > 4 }}")
    println("filterBy(isOdd): ${numbers.filterBy(::isOdd)}")

    // 3 - 集合会立即求值:每一步都产生一个完整的列表
    val largeList = numbers.filter {
        print("[test $it] ")
        it > 7
    }
    println()
    println("the list is already computed: $largeList")

    // 4 - 序列按需求值:
    //     谓词只会被终端操作调用
    val large = numbers.asSequence().filter {
        print("[test $it] ")
        it > 7
    }
    println("the sequence is defined, nothing has been executed yet")
    large.forEach { print("-> $it ") }
    println()

    // 5 - 我们自己的序列中间操作,同样是惰性的
    val cities = listOf("Angers", "Paris", "Lyon", "Nantes", "Aix")
    val result = cities.asSequence()
        .keep { it.length <= 5 }
        .transform(String::uppercase)
        .toList()
    println("our operations: $result")
    // 无限序列:只计算被请求的元素
    val powersOfTwo = generateSequence(1) { it * 2 }
    val firstOnes = powersOfTwo.transform { "2^${it.countTrailingZeroBits()}=$it" }.take(5)
    println("powers of 2: ${firstOnes.toList()}")
}

// 用谓词过滤列表:filter 所做的工作
inline fun <T> List<T>.filterBy(predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (element in this) {
        if (predicate(element)) {
            result.add(element)
        }
    }
    return result
}

fun isOdd(n: Int) = n % 2 != 0

// 一个序列中间操作,只放行满足谓词的元素
fun <T> Sequence<T>.keep(predicate: (T) -> Boolean): Sequence<T> = sequence {
    for (element in this@keep) {
        if (predicate(element)) yield(element)
    }
}

// 一个转换每个元素的中间操作:相当于 map
fun <T, R> Sequence<T>.transform(transformation: (T) -> R): Sequence<R> = sequence {
    for (element in this@transform) {
        yield(transformation(element))
    }
}

结果:

> gradlew -q run -Pmain=lambdas13.Lambdas13Kt
collections: [64, 36, 16, 4]
Stream: [64, 36, 16, 4]
filterBy(n > 4): [8, 6, 5, 9]
filterBy(isOdd): [3, 1, 5, 9]
[test 3] [test 8] [test 1] [test 6] [test 5] [test 4] [test 9] [test 2]
the list is already computed: [8, 9]
the sequence 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]
our operations: [PARIS, LYON, AIX]
powers of 2: [2^0=1, 2^1=2, 2^2=4, 2^3=8, 2^4=16]

注释:

  • 第 9–11 行:来自[filter] 和[map] 的 lambda 首先被赋给变量,以揭示它们的类型。[map] 转换每个元素:由此得到偶数的平方;
  • 第 13 行:使用 Java API 的流进行同样的计算,它可以在 Kotlin 中原样使用:Java 方法[filter] 期望一个[Predicate],[map] 期望一个[Function],而 Kotlin lambda 会被自动转换(SAM 转换)。在 Kotlin 中,它很少用于顺序计算,因为集合和序列函数更简单;它对于第 8 章中的并行流仍然有用,或者当 Java 库返回一个[Stream]时;
  • 第 51–58 行:我们的函数[filterBy],被写成[List<T>] 的扩展函数,并像[inline] 一样被声明为[filter]。它是泛型的:它过滤任何类型[T]的元素列表。它遍历该列表([this]),对每个元素调用谓词(第 54 行),并返回被选中元素的列表;
  • 第 16 行:调用[filterBy] 并传入一个位于圆括号之外的 lambda。类型[T] 由列表推断得出:[Int]。在第 17 行,向它传入的是一个函数引用:[isOdd] (第 61 行)的形式为[(Int) -> Boolean];
  • 第 20–25 行:一个冗长的谓词,它会显示它所测试的每个元素,被应用于一个列表。集合操作是立即执行的:[filter] 测试所有元素,并在返回之前构造出完整的结果列表(结果的第 5–6 行)。因此,在链[list.filter { … }.map { … }]中,每一步都会创建一个中间列表;
  • 第 29–34 行:同一个谓词被应用于序列([asSequence()])。结果(第 7–8 行)表明,序列的定义不会执行任何操作:第 33 行的消息在第一次测试之前就显示了。只有当终端操作[forEach] 请求元素时,谓词才会执行,并且测试与[forEach]的显示交替进行:每个元素在下一个元素进入之前,都会穿过整个链。这就是序列的延迟(或惰性)执行,与 Java 流相同。序列的中间操作不是[inline]:它们必须保留 lambda,以便稍后执行它们;
  • 第 64–73 行:为了编写我们自己的中间操作——它们像库中的操作一样是惰性的——我们使用序列构造函数[sequence]。它接受一个 lambda,其中函数[yield] 产生序列的一个元素:对于下游请求的每个元素,lambda 都从上次中断的地方继续执行,直到下一个[yield] (这是一个协程,我们将在第 9 章学习这一概念)。[this@keep] 的标签指代扩展函数 [keep]的接收者,即原始序列:如果没有标签,[this] 将表示[sequence]中 lambda 的接收者,因为该 lambda 是带接收者的 lambda。函数 [keep] 只放行满足谓词的元素;函数[transform]是双重泛型的([T] 是接收到的元素的类型,[R] 是产生的元素的类型),它返回对每个元素应用该函数的结果。Java 24 为同样的目的引入了中间收集器([Gatherer]),其语法要复杂得多;
  • 第 39–42 行:我们的扩展函数就像库中的操作一样被插入到链中:我们保留至多 5 个字母的城市名,然后把它们转换为大写。终端操作[toList] 触发计算;
  • 第 45–47 行:[generateSequence(1) { it * 2 }] 定义了一个无限序列:1,后面是把前一个元素翻倍得到的每个元素。只有借助惰性求值它才能使用:[take(5)] 只请求前五个元素,并且只计算这些元素。传给[transform] 的 lambda 以[2^n=value] 的形式显示每个幂([countTrailingZeroBits] 统计二进制表示中最右边的零的个数,即指数)。

集合和序列上的所有操作都建立在这一模型之上:接受函数类型的高阶函数。对于集合,这些函数是[inline] 且立即执行的;对于序列,它们保留 lambda,并且只在终端操作请求时才计算元素。

7.8. 表达式树

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

Kotlin 与 Java 一样,没有等价物:Kotlin lambda 总是被编译为可执行代码;它可以被调用,但无法检查其内部工作方式。不过,有几种工具与之相近:

  • 属性引用:[Person::age] 是一个对象([KProperty1<Person, Int>]),它知道属性名称([Person::age.name])及其类型。库可以利用这一点来构造查询而无需编写字符串:例如,Spring Data MongoDB 的 Kotlin 扩展就是这样做的,它们允许你写出诸如[Person::age gt 18]这样的条件;
  • 内部DSL (“领域特定语言”):借助带接收者的 lambda、[infix] 函数和运算符重载,Kotlin 库可以提供类似于 SQL 的语法,程序执行它来构造描述查询的数据结构。这就是 JetBrains 的 Exposed 库背后的原理:[Brackets.selectAll().where { Brackets.limit greater 20000 }];
  • 编译器插件:Kotlin 编译器可以通过转换代码的插件进行扩展。kotlinx.serialization 就是这样工作的,与 Spring 和 Hibernate 一起使用的[all-open] 和[no-arg] 插件,以及[power-assert] 插件也是如此,后者会分析断言的表达式,以便在失败时显示其详细信息。不过,这些是开发工具,而不是程序的内置功能。

我们将在第 11 章介绍的 Hibernate 提供了与 Java 中相同的解决方案:一种类似于 SQL、但以类和属性来表达的查询语言,即HQL (["from Bracket t where t.limit > 20000"]),以及 Jakarta Persistence 的Criteria API,它通过方法调用来构造查询([cb.gt(t.get("limit"), 20000)])。在这两种情况下,查询都是数据(字符串或对象树),由 Hibernate 翻译成 SQL,而传给[filter] 的 lambda 则是在 Kotlin 程序内部执行的。

7.9. 结论

本章的要点:

  • 在 Kotlin 中,函数是值:它们具有函数类型([(Int, Int) -> Int]、[() -> Unit]、[(T) -> Boolean]、[(() -> Unit)?]、[T.() -> R]……),可以存储在变量中、作为参数传递、作为结果返回,并像普通函数一样被调用。对虚拟机而言,它们是实现接口[Function0]、[Function1]……的对象;
  • [java.util.function] 的接口([Function]、[Supplier]、[Consumer]、[Predicate]……),以及[Runnable]、[Callable]和[Comparator]仍然可用:当 Java 方法期望函数式接口时,Kotlin 会自动把 lambda 或引用转换成它(SAM 转换);在其他地方,转换需要显式地写出:[Comparator { … }];
  • 要给函数类型命名,我们有别名[typealias] (只是一个别名)和[fun interface] (一个真正的新类型,可通过 lambda 实现);
  • 函数可以通过 lambda 表达式获得([{ a, b -> a + b }]、[{ it * it }]——当它是最后一个参数时写在圆括号之外,并用[return@label]结束),通过匿名函数,通过匿名对象,或者通过引用([::function]、[object::method]、[Class::method]、[::Class])。指向同一对象的同一函数的两个引用是相等的;两个 lambda 永远不相等;
  • lambda 会捕获其周围的变量,包括[var],并且可以修改它们(编译器把它们存储在[Ref] 对象中);它们随后看到的是变量在其执行时刻的值,这就要求在循环中和线程之间谨慎处理;
  • 返回函数的函数和函数类型上的扩展([then]、[and]、[or]……)可以组合出新函数;[compareBy]、[thenBy]和[reversed] 用来构造比较器;
  • [inline] 函数把它们自己的代码和 lambda 的代码复制到调用处,没有对象也没有转换,并且允许非局部返回;[noinline] 和[crossinline] 处理特殊情况。作用域函数[let]、[run]、[with]、[apply]和[also] 是这一机制最常见的应用;
  • 函数类型用于短期的一次性行为;[fun interface] 用于独立的类型,或者可从 Java 使用的 API;多成员接口(或“业务”接口)用于应用程序的角色;
  • 事件通过监听器模式建立:一个 [XxxEvent] 类、一个监听器类型(通常是函数类型的[typealias])、[addXxxListener] / [removeXxxListener]、以及一个函数列表([CopyOnWriteArrayList]),由[fireXxx] 方法遍历。委托属性[Delegates.observable] 和[Delegates.vetoable] 发出或过滤属性的变更,而[PropertyChangeSupport] 为它们管理监听器列表;
  • 集合操作(立即执行,[inline])和序列操作(惰性)都是高阶函数;Kotlin 没有表达式树,Hibernate 使用 HQL 或 Criteria API 来表达其查询。

lambda 将在后续所有章节中再次出现:线程执行 lambda([thread { … }]),而 [ExecutorService] 执行一个[Callable] (第 8 章);协程由[launch { … }] 或[async { … }] 启动(第 9 章),[ResultSet] 的扩展函数将以 lambda 的形式接收把结果中的一行转换为对象的转换逻辑(第 10 章),而 Spring Boot Web 服务在框架作为监听器调用的方法中处理 HTTP 请求(第 13 章)。