Kotlin与Java虚拟机九:函数是一等公民:Lambda、高阶函数、inline 与契约

26 阅读6分钟

第 9 章 函数是一等公民:Lambda、高阶函数、inline 与契约

本章目标

  1. 搞清 Kotlin 的 Lambda 在 JVM 上到底是什么(三种编译策略、隐藏类、捕获方式);
  2. 精确掌握 inline / noinline / crossinline 的语义与使用准则;
  3. 理解契约(contract)——Kotlin 独有的、让编译器相信你的机制;
  4. 掌握默认参数在字节码层面的实现(以及它带来的二进制兼容陷阱);
  5. 学会用 📌 未使用返回值检查器(2.3) 拦截一整类静默 bug。

9.1 函数声明全解剖

@JvmStatic                                  // 注解
private tailrec infix fun <T : Comparable<T>> List<T>.maxOrNullExt(   // 修饰符 + 泛型 + 接收者 + 名字
    threshold: T? = null,                   // 默认参数
    vararg extras: T,                       // 可变参数
    crossinline transform: (T) -> String,   // Lambda 参数
): String? {                                // 返回类型
    contract {                              // 契约
        callsInPlace(transform, InvocationKind.AT_LEAST_ONCE)
    }
    ...
}

修饰符与关键字全览

关键字作用备注
private/protected/internal/public可见性默认 public
override重写必须显式
open允许被继承/重写默认 final
abstract抽象
final禁止重写(默认)
inline内联函数体到调用点9.5
noinline标记某个 Lambda 参数不内联9.5
crossinline禁止该 Lambda 非局部返回9.5
operator允许运算符语法调用第 17 章
infix允许中缀语法 a op b需单参数、成员或扩展函数
tailrec尾递归优化成循环9.9
suspend挂起函数第 37 章
external由 JNI/Native 实现
expect/actual多平台声明/实现第 48 章

单表达式函数

fun double(x: Int): Int = x * 2      // 显式返回类型(可省略,编译器推断)
fun double2(x: Int) = x * 2          // 推断
fun fact(n: Int): Long = if (n <= 1) 1 else n * fact(n - 1)   // 递归必须显式声明返回类型

📌 表达式体中的 return(2.2.20 引入,2.3.0 默认启用):

fun findUser(id: String): User? =
    users.firstOrNull { it.id == id } ?: return null    // ✅ 现在合法(需显式返回类型)

9.2 默认参数:优雅语法背后的字节码真相

fun greet(name: String, greeting: String = "Hi", punct: String = "!") =
    "$greeting, $name$punct"

编译器生成两个方法:

// ① 真实方法:全参数
public static final String greet(String name, String greeting, String punct)

// ② 合成方法:处理默认值
public static final synthetic String greet$default(
    String name, String greeting, String punct,
    int mask,               // ← 位掩码:哪几位是 1 表示"用默认值"
    Object marker           // ← 永远是 null,用于防止 Java 误调用
)

greet$default 的逻辑(等价 Kotlin):

fun greet$default(name: String, greeting: String, punct: String, mask: Int, marker: Any?): String {
    var g = greeting
    var p = punct
    if (mask and 0b010 != 0) g = "Hi"      // 第 2 个参数用默认值
    if (mask and 0b100 != 0) p = "!"       // 第 3 个参数用默认值
    return greet(name, g, p)
}

调用方:

greet("Kotlin")                       // → greet$default("Kotlin", null, null, 0b110, null)
greet("Kotlin", punct = "?")          // → greet$default("Kotlin", null, "?", 0b010, null)
greet("Kotlin", "Hello")              // → greet$default("Kotlin", "Hello", null, 0b100, null)
greet("Kotlin", "Hello", "?")         // → greet("Kotlin", "Hello", "?")  ← 直接调真实方法

🔬 精妙之处:位掩码让一个合成方法处理所有 2ⁿ 种默认值组合,而不是生成 2ⁿ 个重载。

⚠️ 三个必须知道的陷阱

陷阱 1:Java 调用方看不到默认参数
// Java
GreeterKt.greet("Kotlin");              // ❌ 编译错误:没有这个方法
GreeterKt.greet("Kotlin", "Hi", "!");   // ✅ 必须传全部参数
GreeterKt.greet$default(...);           // ❌ $ 不是合法 Java 标识符(且 marker 参数)

解法:@JvmOverloads

@JvmOverloads
fun greet(name: String, greeting: String = "Hi", punct: String = "!") = ...

编译器额外生成 n 个重载:

greet(String)
greet(String, String)
greet(String, String, String)

⚠️ @JvmOverloads 的限制:

  • 只为连续的、从头开始的参数组合生成重载。greet(name, punct = "?") 在 Java 侧无法表达;
  • 如果有多个默认参数,生成的重载数量 = 默认参数个数 + 1;
  • 可能与手写重载冲突(编译错误)。
陷阱 2:默认参数是二进制不兼容变更(第 5 章已提,这里给证据)
// v1
fun greet(name: String, greeting: String = "Hi")
// 生成:greet(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
//       greet$default(Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Ljava/lang/String;

// v2:加了 punct 参数
fun greet(name: String, greeting: String = "Hi", punct: String = "!")
// 生成:greet(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)...    ← 签名变了!
//       greet$default(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)...

v1 编译的调用方 → NoSuchMethodError。

📌 Kotlin 2.4.0 的 @IntroducedAt(实验) 就是为了解决这个问题:

@IntroducedAt(2, 4)      // 该参数在 2.4 引入
fun greet(name: String, greeting: String = "Hi", punct: String = "!")

编译器会为旧版本生成兼容的重载,让已编译的调用方继续工作。库作者应该关注这个特性。

陷阱 3:默认值表达式在调用时求值,且有副作用
fun log(msg: String, ts: Long = System.currentTimeMillis()) { }

log("a")     // 每次调用都执行 System.currentTimeMillis()

⚠️ 但默认值不能引用其他参数之前的默认值以外的东西(不能引用后面的参数):

fun f(a: Int, b: Int = a * 2) { }        // ✅ 可以引用前面的参数
fun f2(a: Int = b, b: Int) { }           // ❌ 不能引用后面的参数

⚠️ 类成员的默认值可以访问 this:

class Widget(val w: Int = defaultWidth()) {
    private fun defaultWidth() = 100      // ⚠️ 在构造器执行前调用成员方法,this 可能未完全初始化
}

🚀 准则:默认值表达式应该是纯的、无副作用的、不依赖 this 状态的。


9.3 vararg 与展开运算符

fun sum(vararg xs: Int): Int = xs.sum()

sum(1, 2, 3)                    // 直接传
val arr = intArrayOf(1, 2, 3)
sum(*arr)                       // 展开运算符 *

fun <T> listOf2(vararg items: T): List<T> = if (items.isEmpty()) emptyList() else items.asList()

🔬 字节码真相:vararg xs: Int 在 JVM 上就是 int[](原生数组!不装箱)。vararg items: T 是 Object[]。

public static final int sum(int[] xs);
// 调用 sum(1,2,3) 的字节码:
  iconst_3
  newarray  int            // ← 每次调用都分配一个数组!
  dup; iconst_0; iconst_1; iastore
  dup; iconst_1; iconst_2; iastore
  ...
  invokestatic sum:([I)I

⚠️ 每次调用都分配数组(除非 JIT 逃逸分析能消除)。热路径上应避免 vararg,改用 IntArray 参数或 List。

⚠️ vararg 数组是可变的且被调用方持有:

fun f(vararg xs: Int) { xs[0] = 99 }
val a = intArrayOf(1, 2, 3)
f(*a)          // 展开会**复制**数组,所以 a 不受影响 ✅
f(a)           // ❌ 编译错误(类型不匹配)

📌 * 展开运算符在 JVM 上会复制数组(Arrays.copyOf),所以是安全的。但有分配开销。


9.4 Lambda 在 JVM 上到底是什么?—— 三种编译策略

这是理解 Kotlin 性能的关键。

策略 ①:invokedynamic + LambdaMetafactory(📌 JVM IR 后端默认)

val f: (Int) -> Int = { it * 2 }
invokedynamic #20, 0
  // InvokeDynamic #0:invoke:()Lkotlin/jvm/functions/Function1;
  // 引导方法:java.lang.invoke.LambdaMetafactory.metafactory
  //   参数:invoke(Object)Object  ← 擦除后的签名
  //         MethodHandle invokeStatic lambda$main$1(Function1)
  //         invoke(Object)Object

运行时发生什么:

  1. 首次执行到该 invokedynamic 时,调用 LambdaMetafactory.metafactory;
  2. 它用 MethodHandles.Lookup.defineHiddenClass 动态生成一个实现 Function1 的隐藏类;
  3. 把生成的 CallSite 缓存到该指令位置,后续调用直接走缓存。

🔬 隐藏类(Hidden Class,JDK 15+) 的特点:

  • 不在类加载器的命名空间里,无法通过 Class.forName 找到;
  • 不能被其他类引用;
  • 可以被 GC 回收(当所有实例和 CallSite 都不可达时)。

⚠️ 这解释了生产中的两个现象:

  1. jcmd <pid> GC.class_histogram 里会看到大量 ...$$Lambda$14/0x0000... 的类;
  2. Metaspace 使用量随 Lambda 数量增长(每个 Lambda 位置生成一个隐藏类)。

📌 关键优化:非捕获 Lambda 是单例

val nonCapturing: (Int) -> Int = { it * 2 }       // 不捕获外部变量
val capturing: (Int) -> Int = { it * offset }     // 捕获 offset
  • 非捕获:LambdaMetafactory 生成的 CallSite 返回同一个实例(缓存的常量),零分配 ✅
  • 捕获:每次执行 invokedynamic 都创建一个新实例(把捕获的值存进字段)❌

🧪 实验 9-1:验证分配差异

@Benchmark fun nonCapturing(): Int {
    val list = listOf(1, 2, 3)
    return list.filter { it > 1 }.size          // filter 是 inline,无 Lambda 对象
}

@Benchmark fun capturingAlloc(): Int {
    val threshold = 1
    val f: (Int) -> Boolean = { it > threshold } // 捕获 → 每次分配
    return listOf(1,2,3).count(f)
}

用 -prof gc 观察 gc.alloc.rate.norm。

策略 ②:匿名内部类(-Xlambdas=class)

compilerOptions { freeCompilerArgs.add("-Xlambdas=class") }

编译器为每个 Lambda 生成一个真实的内部类:

public final class MainKt$main$1 implements Function1<Integer, Integer> {
    final int $captured_offset$0;
    public MainKt$main$1(int i) { this.$captured_offset$0 = i; }
    public Object invoke(Object p) { return Integer.valueOf(invoke((Integer)p)); }
    public final int invoke(Integer i) { return i * this.$captured_offset$0; }
}

对比:

indy(默认)class
class 文件数量少(运行时生成隐藏类)多(编译期生成)
jar 体积小大
Metaspace运行时增长加载时确定
启动速度首次调用有 LambdaMetafactory 开销略快
Native Image 兼容性需要额外配置更好
Android(dex)需要 desugaring直接支持

🚀 选择建议:

  • 服务端 JVM:用默认的 indy(jar 更小);
  • GraalVM Native Image / Android:class 模式有时更省心;
  • 📌 SAM 转换也有对应选项:-Xsam-conversions=indy(默认)/ class。

策略 ③:inline —— Lambda 彻底消失

见 9.5。

函数类型的 JVM 表示

(Int) -> String                    // kotlin.jvm.functions.Function1<Integer, String>
(Int, Long) -> Boolean             // Function2<Integer, Long, Boolean>
() -> Unit                         // Function0<Unit>
suspend (Int) -> String            // kotlin.coroutines.SuspendFunction1<Integer, String>

🔬 标准库定义了 Function0 到 Function22(22 是 Scala 的历史影响)。超过 22 个参数时,编译器会为该调用点生成专用接口。

⚠️ 注意装箱:Function1<Integer, String> 的 invoke(Object): Object 是擦除后的签名。所以 (Int) -> Int 的 Lambda 每次调用都装箱两次(参数 + 返回值)!

val f: (Int) -> Int = { it * 2 }
f(21)      // Integer.valueOf(21) → invoke(Object) → Integer.valueOf(42) → 拆箱

🚀 这就是为什么标准库的所有高阶函数都是 inline:

public inline fun <T, R> T.let(block: (T) -> R): R = block(this)

内联后 block(this) 被替换为 Lambda 体,参数和返回值都是原生类型,零装箱。


9.5 inline / noinline / crossinline 精确语义

inline:把函数体复制到调用点

public inline fun <T, R> T.let(block: (T) -> R): R {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    return block(this)
}

调用点:

val len = name?.let { it.length }

编译后(等价 Java):

String len;
if (name != null) {
    len = name.length();        // Lambda 体直接内联,无 Function1 对象
} else {
    len = null;
}

四大收益:

  1. 消除 Lambda 对象分配(捕获型 Lambda 每次分配);
  2. 消除 Function1.invoke(Object) 的装箱(参数/返回值都是原生类型);
  3. 消除一次间接调用(JIT 更容易进一步优化);
  4. 启用高级能力:reified 类型参数、非局部返回、非局部 break/continue。

三大代价:

  1. 代码膨胀:函数体在每个调用点复制一份 → jar 变大、CodeCache 压力、I-cache 命中率下降;
  2. 二进制兼容:修改 inline 函数体,已编译的调用方不会更新(必须全量重编译);
  3. 递归限制:inline 函数不能递归调用自己(会无限展开),除非通过非 inline 的间接层。

noinline:让某个 Lambda 参数不内联

inline fun doWithLogging(inlined: () -> Unit, noinline stored: () -> Unit) {
    println("before")
    inlined()                 // 内联展开
    callbacks.add(stored)     // ✅ 需要把 Lambda 当对象存储,所以不能内联
    println("after")
}

什么时候需要 noinline:

  • 把 Lambda 存起来(放进集合、字段);
  • 把 Lambda 传给另一个非 inline 函数;
  • 把 Lambda 在异步回调里执行(跨越当前栈帧)。

crossinline:禁止非局部返回

inline fun runLater(crossinline block: () -> Unit) {
    handler.post { block() }      // block 在另一个执行上下文里被调用
}

runLater { return }               // ❌ 编译错误:return 不允许在这里

为什么需要:非局部返回要求"Lambda 体与调用方在同一个栈帧"。如果 Lambda 被传给另一个 Lambda(handler.post { ... })或异步执行,非局部返回就无法实现(会导致栈帧已弹出却试图 return)。

crossinline = "我会内联你,但你不能非局部返回"。

三者对照

修饰符内联函数体允许非局部返回可作为对象存储
(无)✅✅❌(编译器报错)
noinline❌❌✅
crossinline✅❌❌

⚠️ public inline 的封装限制

class Secret {
    private val key = "abc"
    public inline fun leak() = println(key)    // ❌ 编译错误:PUBLIC-API_INLINE_ERROR
}

原因:inline 函数体会被复制到调用方(可能在别的模块)。如果它访问了 private 成员,调用方的字节码就会直接访问那个私有字段 → 破坏封装。

解法:

  1. 把成员改成 internal 并加 @PublishedApi:
class Secret {
    @PublishedApi internal val key = "abc"
    public inline fun leak() = println(key)    // ✅
}
  1. 或者把 inline 函数改成非 inline。

⚠️ @PublishedApi internal 的成员实际上是公开 API(会被内联进调用方),修改它同样是二进制不兼容变更。用它要非常谨慎。

inline 的使用准则(🚀 背下来)

✅ 应该 inline:

  • 接受 Lambda 参数的小函数(let/run/apply/also/with/use/repeat/forEach);
  • 需要 reified 类型参数的函数;
  • 需要非局部返回/break/continue 的函数;
  • 需要 contract 且函数体小的函数。

❌ 不应该 inline:

  • 不含 Lambda 参数的函数(纯代码膨胀);
  • 函数体大的(> 20 行);
  • 需要递归的;
  • 会被极高频调用的(每次调用都复制一份代码 → CodeCache 爆炸)。

🔬 一个数据点:kotlin.collections 里几乎所有高阶函数都是 inline,而 kotlin.text 里的字符串处理函数大多不是。这个分布本身就是最好的教材。


9.6 契约(Contracts):让编译器相信你

四种契约形式

contract {
    // ① returns() implies (条件):函数正常返回时,条件成立
    returns() implies (x != null)

    // ② returns(值) implies (条件):函数返回特定值时,条件成立
    returns(true) implies (x is String)

    // ③ returnsNotNull():函数不会返回 null
    returnsNotNull()

    // ④ callsInPlace(lambda, 调用次数):Lambda 会被调用几次
    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    callsInPlace(block, InvocationKind.AT_MOST_ONCE)
    callsInPlace(block, InvocationKind.AT_LEAST_ONCE)
    callsInPlace(block, InvocationKind.UNKNOWN)
}

标准库中的应用

// kotlin.Preconditions.kt
public inline fun <T : Any> requireNotNull(value: T?): T {
    contract { returns() implies (value != null) }
    return value ?: throw IllegalArgumentException(...)
}

// kotlin.Standard.kt
public inline fun <R> run(block: () -> R): R {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    return block()
}

// kotlin.collections
public inline fun <T> List<T>.firstOrNull(predicate: (T) -> Boolean): T? { ... }

契约带来的三种能力

能力 ①:智能转换跨越函数边界
fun process(x: Any?) {
    require(x is String)          // 带 contract: returns() implies (x is String)
    println(x.length)             // ✅ 智能转换生效!
}

fun check(s: String?): Int {
    if (s.isNullOrEmpty()) return 0    // contract: returns(false) implies (this != null)
    return s.length                    // ✅ s 已知非空
}
能力 ②:在 Lambda 里初始化 val
val x: Int
run { x = 42 }              // ✅ 因为 run 的 contract 声明 EXACTLY_ONCE
println(x)                  // ✅ 编译器确定 x 已初始化

val y: Int
if (cond) { y = 1 } else { y = 2 }   // ✅ 不需要 contract,编译器能分析

val z: Int
repeat(3) { z = it }        // ❌ repeat 的 contract 是 AT_LEAST_ONCE?实际上 repeat 没有 EXACTLY_ONCE 契约
                            //    → 编译错误:Variable 'z' must be initialized
能力 ③:自定义契约(需要 opt-in)
@OptIn(ExperimentalContracts::class)
fun <T> T?.orElseThrow(msg: String): T {
    contract { returns() implies (this@orElseThrow != null) }
    return this ?: throw IllegalStateException(msg)
}

fun f(s: String?) {
    val x = s.orElseThrow("must not be null")
    // 之后 s 也已知非空
    println(s.length)          // ✅
}

⚠️ 契约是"承诺",编译器不验证。如果你撒谎:

@OptIn(ExperimentalContracts::class)
fun bad(x: Any?): Boolean {
    contract { returns(true) implies (x is String) }
    return x is Int             // ← 撒谎!返回 true 时 x 其实是 Int
}

fun crash(o: Any?) {
    if (bad(o)) {
        println(o.length)       // 编译器认为是 String → 生成 String.length() 调用
    }                           // 运行时:ClassCastException 或 VerifyError 💥
}

🚀 准则:

  1. 优先使用标准库已带契约的函数(require/check/requireNotNull/checkNotNull/run/let/isNullOrEmpty/isNullOrBlank);
  2. 自定义契约要极其谨慎,且必须有充分的单元测试覆盖契约声明;
  3. 契约是 ExperimentalContracts,📌 截至 Kotlin 2.4 仍未稳定,API 可能变化。

9.7 SAM 转换

Java 接口(自动)

val thread = Thread { println("hi") }                    // Runnable SAM 转换
button.setOnClickListener { view -> handleClick(view) }   // OnClickListener
executor.submit(Callable { compute() })

Kotlin 接口(需要 fun interface)

// ❌ 普通 Kotlin 接口不能 SAM 转换
interface Handler { fun handle(e: Event) }
val h = Handler { }         // 编译错误

// ✅ 函数式接口
fun interface Handler { fun handle(e: Event) }
val h = Handler { e -> println(e) }      // ✅

📌 Kotlin 1.4 起支持 Kotlin fun interface 的 SAM 转换。

fun interface 的设计考量

fun interface Comparator<T> {          // 标准库就是这么定义的
    fun compare(a: T, b: Int): Int
}

⚠️ 约束:fun interface 只能有一个抽象方法(可以有默认方法、静态方法)。

🔬 SAM 转换的字节码:与 Lambda 一样走 invokedynamic + LambdaMetafactory(📌 可通过 -Xsam-conversions=class 改为生成类)。

🚀 什么时候用 fun interface vs 函数类型 (T) -> R:

fun interface函数类型
语义清晰度✅ 方法有名字(handle(e))❌ invoke
可以有自己的文档✅❌
可以有多个默认方法✅❌
使用简洁度略繁琐✅
Java 互操作✅ 天然 SAM需要包装

准则:公开 API 的回调优先用 fun interface(更清晰、可扩展);内部的小回调用函数类型。


9.8 闭包捕获:字段 vs Ref 包装

fun demo() {
    val immutable = 42             // val 基本类型
    val objRef = Object()          // val 引用类型
    var mutable = 0                // var 基本类型
    var mutableObj: String? = null // var 引用类型

    val f = {
        println(immutable)         // 捕获为字段(final)
        println(objRef)            // 捕获为字段(final)
        mutable++                  // ⚠️ 通过 Ref.IntRef 访问
        mutableObj = "x"           // ⚠️ 通过 Ref.ObjectRef 访问
    }
    f()
}

编译结果:

public final class DemoKt$demo$f$1 extends Lambda implements Function0<Unit> {
    final int $captured_immutable$0;      // val 基本类型 → 值拷贝字段
    final Object $captured_objRef$1;      // val 引用 → 引用字段
    final Ref.IntRef $captured_mutable$2; // var 基本类型 → Ref 包装!
    final Ref.ObjectRef $captured_mutableObj$3;
    ...
}

🔬 kotlin.jvm.internal.Ref 家族:

public static class IntRef    { public int element; }
public static class LongRef   { public long element; }
public static class ObjectRef { public Object element; }
public static class BooleanRef, ByteRef, CharRef, ShortRef, FloatRef, DoubleRef

⚠️ 三个后果:

  1. 分配:每个被捕获的可变基本类型变量分配一个 Ref 对象;
  2. 线程不安全:Ref.element 是裸字段,非 volatile。如果 Lambda 在多线程中执行,可见性无保证;
  3. inline 消除这一切:
var sum = 0
list.forEach { sum += it }       // forEach 是 inline → sum 就在栈帧里,无 Ref
val g = { sum += 1 }             // 非 inline → 分配 Ref.IntRef

🚀 多线程场景的正确写法:

// ❌ 危险:Ref.IntRef 非线程安全
var counter = 0
list.parallelStream().forEach { counter++ }

// ✅ 用 AtomicInteger
val counter = AtomicInteger()
list.parallelStream().forEach { counter.incrementAndGet() }

// ✅ 或用协程 + Mutex / 归约
val total = list.sumOf { it.toLong() }

9.9 tailrec:真正的尾递归优化

tailrec fun factorial(n: Int, acc: Long = 1): Long =
    if (n <= 1) acc else factorial(n - 1, acc * n)

编译成循环:

public static final long factorial(int n, long acc) {
loop:
    if (n <= 1) return acc;
    long newAcc = acc * n;
    n = n - 1;
    acc = newAcc;
    goto loop;              // ← 无新栈帧!
}

🔬 JVM 本身不支持尾调用优化(TCO)。Kotlin 通过编译器改写实现,这是语言层的功劳。

tailrec 的约束:

  1. 递归调用必须在尾位置(是函数体的最后一个操作);
  2. 支持在 when/if 分支的尾位置;
  3. 不支持在 try/catch/finally 块中(因为异常处理需要栈帧);
  4. 不满足条件时编译错误(不是警告),所以你不会误以为有优化。
tailrec fun bad(n: Int): Int =
    try { if (n <= 0) 0 else bad(n - 1) + 1 }   // ❌ 不是尾位置(有 +1)+ 在 try 里
    catch (e: Exception) { 0 }

🚀 什么时候用:

  • 递归算法的自然表达(遍历树、状态机、解析器);
  • 深度可能很大(> 几千层)会栈溢出的场景;
  • 不要用 tailrec 替代普通循环来"显得函数式"——可读性通常更差。

⚠️ 默认栈大小:-Xss 默认 1MB(约 1 万层 Kotlin 调用帧)。协程的挂起不占栈,但普通递归会。


9.10 函数引用

val f1 = ::println                    // 顶层/标准库函数引用
val f2 = String::length               // 类的成员引用(未绑定)
val f3 = "abc"::length                // 实例的绑定引用
val f4 = MyClass::staticMethod
val f5 = ::MyClass                    // 构造器引用
val f6 = String::isNullOrEmpty        // 扩展函数引用

🔬 字节码真相:函数引用生成 FunctionReference 对象:

public final class MainKt$f1$1 extends FunctionReferenceImpl implements Function1<String, Integer> {
    public String getName() { return "length"; }
    public String getSignature() { return "length()I"; }
    public Object invoke(Object p) { return Integer.valueOf(((String)p).length()); }
}

⚠️ 代价:

  1. 分配一个对象(除非在 inline 上下文中被消除);
  2. 反射式调用(FunctionReferenceImpl 内部持有 KFunction,调用可能走反射路径)→ 比 Lambda 慢;
  3. 在热路径上,{ it.length } 通常比 String::length 快(Lambda 可以被 JIT 完全内联,函数引用不行)。

🧪 实验 9-2:函数引用 vs Lambda 的性能

@Benchmark fun withLambda(list: List<String>) = list.sumOf { it.length }
@Benchmark fun withRef(list: List<String>)    = list.sumOf(String::length)

通常 withLambda 更快(Lambda 内联后无对象、无间接调用)。

🚀 准则:函数引用用于可读性(list.map(User::name) 比 list.map { it.name } 更清晰),不用于性能。在超热路径上优先 Lambda。


9.11 📌 未使用返回值检查器(Kotlin 2.3.0 实验)

问题

fun format(name: String): String {
    if (name.isBlank()) return "anonymous"
    if (!name.contains(' ')) {
        "Hello, " + name.replaceFirstChar(Char::titlecase) + "!"    // ← 结果被丢弃!
        // 开发者大概是想 return,但忘了
    }
    val (first, last) = name.split(' ')
    return "Hello, $first!"
}

这类 bug 静默地存在,Java 和旧版 Kotlin 都不会警告。

解法

compilerOptions {
    freeCompilerArgs.add("-Xreturn-value-checker=check")   // 只检查被标记的作用域
    // 或
    freeCompilerArgs.add("-Xreturn-value-checker=full")    // 检查项目内所有函数
}

配合注解:

@file:MustUseReturnValues          // 标记整个文件
package my.project

@MustUseReturnValues               // 或标记一个类
class Greeter { fun greet(name: String): String = "Hi $name" }

@IgnorableReturnValue              // 豁免某个函数(如 MutableList.add)
fun <T> MutableList<T>.addAndIgnore(e: T): Boolean = add(e)

抑制单次警告:

val _ = computeValue()      // 赋值给下划线变量,明确表示"我知道,我就是要丢弃"

📌 _ 作为"故意丢弃"的标记是 Kotlin 2.3 引入的惯用法,语义清晰且不需要 @Suppress。

🚀 建议:在新项目中开启 =check 模式 + 对核心包加 @MustUseReturnValues。这是投入极小、拦截一类真实 bug 的措施。

⚠️ 注意:检查器忽略 ++/-- 的返回值(因为 counter++ 的惯用写法就是丢弃返回值)。


9.12 局部函数与代码复用

fun process(order: Order): Result {
    // 局部函数:可以访问外层作用域,避免重复参数传递
    fun validate(field: String, value: Any?) {
        requireNotNull(value) { "$field must not be null in order ${order.id}" }
    }

    validate("customer", order.customer)
    validate("amount", order.amount)
    validate("currency", order.currency)

    return compute(order)
}

🔬 局部函数编译为:

  • 如果不捕获外层变量 → 编译为私有静态方法(零开销);
  • 如果捕获 → 编译为 Lambda 对象或带 this 引用的方法。

🚀 局部函数的价值:

  1. 减少参数传递(自动捕获上下文);
  2. 限制作用域(只在需要的地方可见,降低认知负担);
  3. 避免命名冲突(不用给辅助函数起全局唯一的名字)。

⚠️ 滥用警告:如果一个函数里有 3 个以上的局部函数,通常意味着应该重构成独立的类。


9.13 本章小结

  1. 默认参数编译为"真实方法 + $default 合成方法 + 位掩码",比生成 2ⁿ 个重载优雅得多;但新增默认参数是二进制不兼容变更(📌 2.4 的 @IntroducedAt 提供了官方解法)。Java 互操作需要 @JvmOverloads。
  2. Lambda 有三种编译策略:invokedynamic + 运行时隐藏类(默认)、生成匿名类、inline 展开。非捕获 Lambda 是单例(零分配),捕获 Lambda 每次分配。
  3. 函数类型 (Int) -> Int 在 JVM 上是 Function1<Integer,Integer>,调用会装箱两次——这就是标准库所有高阶函数都是 inline 的原因。
  4. inline 的四大收益与三大代价。准则:只对"小的、接受 Lambda 的"函数使用。
  5. noinline(要存储 Lambda) 和 crossinline(Lambda 在别的执行上下文里被调用) 是精确的工具,不是修饰性的。
  6. 契约(contract)让编译器跨越函数边界做数据流分析——这是 Kotlin 独有的能力,require/check/run/isNullOrEmpty 都靠它。自定义契约需要 @OptIn(ExperimentalContracts::class),且编译器不验证你说的是真话。
  7. 捕获可变基本类型变量会生成 Ref.IntRef(额外分配 + 非线程安全);inline 函数里不会。
  8. tailrec 是编译器改写为循环,JVM 本身没有 TCO。
  9. 函数引用比 Lambda 慢(分配 + 可能的反射路径),用于可读性而非性能。
  10. 📌 未使用返回值检查器(2.3) 用 @MustUseReturnValues + val _ = f() 拦截一整类静默 bug。

9.14 练习题

9-1. 下列代码各分配多少个对象?(假设 list 有 100 个元素)

fun f(list: List<Int>) {
    val a = list.filter { it > 50 }                    // ①
    val b = list.map { it * 2 }                        // ②
    val threshold = 50
    val c = list.filter { it > threshold }             // ③
    val d: (Int) -> Boolean = { it > threshold }       // ④
    val e = list.count(d)                              // ⑤
    var sum = 0
    list.forEach { sum += it }                          // ⑥
    val g = { sum += 1 }                               // ⑦
    g()
}
答案要点

① 1 个 ArrayList(结果集合)+ 可能的迭代器(会被 JIT 消除)。filter 是 inline → Lambda 对象 0 个。装箱:it > 50 中 it 是 Integer 拆箱,不产生新对象;结果 ArrayList 存的是原 Integer 引用,不新装箱。 ② 1 个 ArrayList + 100 个 Integer(it * 2 的结果要装箱存进 List<Int>)。 ③ 1 个 ArrayList。Lambda 捕获 threshold,但 filter 是 inline → 无 Function 对象、无 Ref 包装(threshold 是 val,直接内联为常量)。 ④ 1 个 Lambda 对象(捕获 threshold → 每次执行都分配)+ 1 个 Ref.IntRef?不需要(threshold 是 val,直接作为字段捕获)。 ⑤ 0 个(count 是 inline,传入的 d 已是对象,不新分配)。但 count 内部调用 d.invoke(Integer) → 装箱 100 次(因为 d 是 Function1<Integer, Boolean>,非 inline 调用)。 ⑥ 0 个(forEach 是 inline,sum 是局部 var 但在 inline lambda 里 → 不需要 Ref,直接操作栈帧变量)。 ⑦ 1 个 Lambda 对象 + 1 个 Ref.IntRef(非 inline lambda 捕获可变的 sum)。

总计约:4 个 ArrayList/Lambda/Ref 对象 + 100 个 Integer 装箱 + 100 次 count 的装箱调用。

关键教训:⑥ 和 ⑦ 的对比最能说明 inline 的价值——同样是"lambda 捕获 var",一个零分配一个两次分配。

9-2. 为什么 public inline fun 不能访问 private 成员?@PublishedApi 解决了什么,又带来了什么新问题?

答案要点

原因:inline 函数体会被复制到调用方的字节码里。如果调用方在另一个模块/包,复制过去的代码就直接访问了原本 private 的字段/方法——JVM 的访问检查会失败(IllegalAccessError),或者更糟,如果编译器允许,就破坏了封装。

@PublishedApi internal 的作用:告诉编译器"我知道这个成员会被内联暴露,请允许"。成员编译为 public(JVM 层面),但 Kotlin 语言层面仍标记为 internal(IDE 会警告外部使用)。

新问题:

  1. 它实际上是公开 API:任何调用方内联后都直接依赖它的实现细节;
  2. 修改它 = 二进制不兼容变更,但二进制兼容验证器可能检测不到(因为它在 Kotlin 元数据里是 internal);
  3. 重命名/改签名会让已编译的调用方 NoSuchFieldError/NoSuchMethodError;
  4. 反射可以访问它(因为 JVM 层面是 public)。

准则:@PublishedApi 应该只用于稳定的、简单的、不会变的内部实现细节(如一个常量、一个简单的辅助函数)。任何复杂逻辑都应该放在非 inline 的私有函数里,由 inline 函数调用它。

9-3.(🧪 动手)写一个带 contract 的自定义函数,让编译器在调用后能智能转换。验证:如果 contract 撒谎,会发生什么?

答案要点
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Any> Any?.asOrNull(): T? {
    contract { returnsNotNull() implies (this@asOrNull is T) }   // ⚠️ 这个方向是错的示范
    return this as? T
}

// 正确的示范:
@OptIn(ExperimentalContracts::class)
fun isValid(s: String?): Boolean {
    contract { returns(true) implies (s != null) }
    return s != null && s.length > 3
}

fun use(s: String?) {
    if (isValid(s)) println(s.length)   // ✅ 智能转换生效
}

撒谎的后果:

@OptIn(ExperimentalContracts::class)
fun lies(x: Any?): Boolean {
    contract { returns(true) implies (x is String) }
    return x is Int          // 返回 true 时 x 其实是 Int
}

fun crash(o: Any?) {
    if (lies(o)) println(o.length)   // 编译器认为是 String,生成 String.length() 调用
}
crash(42)

运行时结果:java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String(因为智能转换生成了 checkcast 指令)。

注意:JVM 的字节码验证器 + checkcast 指令是最后一道防线,所以你不会得到"未定义行为",而是明确的 ClassCastException。但在某些情况下(如原始类型、泛型擦除)可能得到更隐蔽的错误。

结论:契约是类型系统的可信扩展点,撒谎会破坏类型安全。必须有测试覆盖。

9-4. noinline 和 crossinline 分别解决什么问题?给出各一个真实场景。

答案要点

noinline:解决"Lambda 需要作为对象存在"的问题。 场景:注册回调

class EventBus {
    private val handlers = mutableListOf<(Event) -> Unit>()
    inline fun on(crossinline filter: (Event) -> Boolean, noinline handler: (Event) -> Unit) {
        handlers.add(handler)              // 存储 → 必须是对象
    }
}

crossinline:解决"Lambda 在另一个执行上下文中被调用,非局部返回无法实现"的问题。 场景:异步/嵌套执行

inline fun onUiThread(crossinline block: () -> Unit) {
    if (isUiThread()) block() else handler.post { block() }   // post 的 lambda 里调用 block
}
// 调用方:onUiThread { return }  ← 编译错误,因为 block 可能在别的线程执行,外层栈帧已消失

对比记忆:

  • noinline = "别内联,我要把它当对象用";
  • crossinline = "内联,但不许非局部返回,因为你会跨越执行上下文"。

9-5. 你的团队在 code review 中发现大量 !!。用本章知识,给出五种消除 !! 的手段,并说明各自适用场景。

答案要点
  1. 局部 val + 智能转换:适用于多线程下的 var 属性、平台类型。
    val v = obj.field ?: return
    use(v)
    
  2. ?.let { }:适用于"非空时执行一段逻辑"。
  3. ?: + return/throw:适用于卫语句式的提前退出。
  4. requireNotNull(x) { "context" } / checkNotNull:适用于不变量断言("这里逻辑上不可能为 null,如果为 null 说明有 bug")。优于 !! 的三点:带 contract(支持智能转换)、语义化异常类型、可携带上下文信息。
  5. 自定义 contract 函数:适用于领域特定的校验(isValid、asNonNull),让编译器理解你的领域不变量。
  6. (进阶)类型重设计:用 sealed class 表达"缺失的原因",用 value class 表达"已验证的值"(第 7 章)。这是根治手段。

工程配套:Detekt 开启 UnsafeCallOnNullableType + allWarningsAsErrors,CI 拦截。


9.15 面试题精选

Q1:Kotlin 的 Lambda 和 Java 的 Lambda 在实现上有什么区别?

答题框架:

  • 相似:都可以用 invokedynamic + LambdaMetafactory,运行时生成隐藏类。
  • Kotlin 独有能力:
    1. inline:把 Lambda 体复制到调用点,彻底消除对象分配与装箱——Java 没有对应机制(Java 的 Lambda 一定会生成 CallSite);
    2. reified 类型参数:内联后类型信息保留,可以 is T、T::class——Java 做不到;
    3. 非局部返回 / break / continue(📌 2.2 稳定)——Java 的 Lambda 只能 return 自身;
    4. 契约:callsInPlace 让编译器知道 Lambda 的调用次数,支持在 Lambda 里初始化 val。
  • 配置差异:Kotlin 有 -Xlambdas=indy|class 和 -Xsam-conversions=indy|class 两种策略可切换。
  • 捕获差异:Kotlin 对捕获的可变基本类型变量生成 Ref.IntRef 包装;Java 不允许 Lambda 捕获可变局部变量(必须 effectively final)。

Q2:inline 函数有什么代价?什么时候不该用?

见 9.5。答题要点:代码膨胀(jar 大小、CodeCache、I-cache)、二进制兼容(调用方需重编译)、不能递归、public inline 无法访问 private 成员(需 @PublishedApi)。不该用:无 Lambda 参数的函数、大函数体、超高频调用点。

Q3:什么是 Kotlin 的 contract?它能做什么?有什么风险?

答题框架:

  • 定义:函数体内 contract { } 块,向编译器声明"关于这个函数行为的额外公理"。
  • 四种形式:returns() implies (...)、returns(值) implies (...)、returnsNotNull()、callsInPlace(lambda, kind)。
  • 三大能力:跨函数边界的智能转换;在 Lambda 里初始化 val;自定义类型收窄函数。
  • 标准库应用:require/check/requireNotNull/checkNotNull/run/let/apply/also/isNullOrEmpty/isNullOrBlank/takeIf。
  • 风险:📌 仍是 ExperimentalContracts(需 opt-in);编译器不验证契约的真实性,撒谎会导致 ClassCastException 或逻辑错误;只能写在函数体的第一个语句。
  • 加分:给出一个自定义 contract 的完整例子。

Q4:Kotlin 的默认参数是怎么实现的?为什么它对二进制兼容不友好?

见 9.2。答题要点:$default 合成方法 + 位掩码 + Object marker;Java 侧需 @JvmOverloads;新增默认参数会改变真实方法与 $default 的签名 → NoSuchMethodError;📌 Kotlin 2.4 的 @IntroducedAt 是官方解法。


下一章预告:第 10 章《作用域函数、DSL 与 context parameters》——let/run/with/apply/also 到底怎么选?扩展函数为什么是"静态解析"的?@DslMarker 如何防止 DSL 的作用域泄漏?以及 📌 Kotlin 2.4 转正的 context parameters 如何取代 context receivers,成为依赖注入与 DSL 设计的新工具。