第 9 章 函数是一等公民:Lambda、高阶函数、inline 与契约
本章目标
- 搞清 Kotlin 的 Lambda 在 JVM 上到底是什么(三种编译策略、隐藏类、捕获方式);
- 精确掌握
inline/noinline/crossinline的语义与使用准则;- 理解契约(contract)——Kotlin 独有的、让编译器相信你的机制;
- 掌握默认参数在字节码层面的实现(以及它带来的二进制兼容陷阱);
- 学会用 📌 未使用返回值检查器(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
运行时发生什么:
- 首次执行到该
invokedynamic时,调用LambdaMetafactory.metafactory; - 它用
MethodHandles.Lookup.defineHiddenClass动态生成一个实现Function1的隐藏类; - 把生成的
CallSite缓存到该指令位置,后续调用直接走缓存。
🔬 隐藏类(Hidden Class,JDK 15+) 的特点:
- 不在类加载器的命名空间里,无法通过
Class.forName找到; - 不能被其他类引用;
- 可以被 GC 回收(当所有实例和 CallSite 都不可达时)。
⚠️ 这解释了生产中的两个现象:
jcmd <pid> GC.class_histogram里会看到大量...$$Lambda$14/0x0000...的类;- 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;
}
四大收益:
- 消除 Lambda 对象分配(捕获型 Lambda 每次分配);
- 消除
Function1.invoke(Object)的装箱(参数/返回值都是原生类型); - 消除一次间接调用(JIT 更容易进一步优化);
- 启用高级能力:
reified类型参数、非局部返回、非局部break/continue。
三大代价:
- 代码膨胀:函数体在每个调用点复制一份 → jar 变大、CodeCache 压力、I-cache 命中率下降;
- 二进制兼容:修改 inline 函数体,已编译的调用方不会更新(必须全量重编译);
- 递归限制: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 成员,调用方的字节码就会直接访问那个私有字段 → 破坏封装。
解法:
- 把成员改成
internal并加@PublishedApi:
class Secret {
@PublishedApi internal val key = "abc"
public inline fun leak() = println(key) // ✅
}
- 或者把 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 💥
}
🚀 准则:
- 优先使用标准库已带契约的函数(
require/check/requireNotNull/checkNotNull/run/let/isNullOrEmpty/isNullOrBlank); - 自定义契约要极其谨慎,且必须有充分的单元测试覆盖契约声明;
- 契约是
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
⚠️ 三个后果:
- 分配:每个被捕获的可变基本类型变量分配一个
Ref对象; - 线程不安全:
Ref.element是裸字段,非 volatile。如果 Lambda 在多线程中执行,可见性无保证; 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 的约束:
- 递归调用必须在尾位置(是函数体的最后一个操作);
- 支持在
when/if分支的尾位置; - 不支持在
try/catch/finally块中(因为异常处理需要栈帧); - 不满足条件时编译错误(不是警告),所以你不会误以为有优化。
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()); }
}
⚠️ 代价:
- 分配一个对象(除非在 inline 上下文中被消除);
- 反射式调用(
FunctionReferenceImpl内部持有KFunction,调用可能走反射路径)→ 比 Lambda 慢; - 在热路径上,
{ 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引用的方法。
🚀 局部函数的价值:
- 减少参数传递(自动捕获上下文);
- 限制作用域(只在需要的地方可见,降低认知负担);
- 避免命名冲突(不用给辅助函数起全局唯一的名字)。
⚠️ 滥用警告:如果一个函数里有 3 个以上的局部函数,通常意味着应该重构成独立的类。
9.13 本章小结
- 默认参数编译为"真实方法 +
$default合成方法 + 位掩码",比生成 2ⁿ 个重载优雅得多;但新增默认参数是二进制不兼容变更(📌 2.4 的@IntroducedAt提供了官方解法)。Java 互操作需要@JvmOverloads。 - Lambda 有三种编译策略:
invokedynamic+ 运行时隐藏类(默认)、生成匿名类、inline展开。非捕获 Lambda 是单例(零分配),捕获 Lambda 每次分配。 - 函数类型
(Int) -> Int在 JVM 上是Function1<Integer,Integer>,调用会装箱两次——这就是标准库所有高阶函数都是inline的原因。 inline的四大收益与三大代价。准则:只对"小的、接受 Lambda 的"函数使用。noinline(要存储 Lambda) 和crossinline(Lambda 在别的执行上下文里被调用) 是精确的工具,不是修饰性的。- 契约(contract)让编译器跨越函数边界做数据流分析——这是 Kotlin 独有的能力,
require/check/run/isNullOrEmpty都靠它。自定义契约需要@OptIn(ExperimentalContracts::class),且编译器不验证你说的是真话。 - 捕获可变基本类型变量会生成
Ref.IntRef(额外分配 + 非线程安全);inline函数里不会。 tailrec是编译器改写为循环,JVM 本身没有 TCO。- 函数引用比 Lambda 慢(分配 + 可能的反射路径),用于可读性而非性能。
- 📌 未使用返回值检查器(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 会警告外部使用)。
新问题:
- 它实际上是公开 API:任何调用方内联后都直接依赖它的实现细节;
- 修改它 = 二进制不兼容变更,但二进制兼容验证器可能检测不到(因为它在 Kotlin 元数据里是 internal);
- 重命名/改签名会让已编译的调用方
NoSuchFieldError/NoSuchMethodError; - 反射可以访问它(因为 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 中发现大量 !!。用本章知识,给出五种消除 !! 的手段,并说明各自适用场景。
答案要点
- 局部
val+ 智能转换:适用于多线程下的var属性、平台类型。val v = obj.field ?: return use(v) ?.let { }:适用于"非空时执行一段逻辑"。?:+return/throw:适用于卫语句式的提前退出。requireNotNull(x) { "context" }/checkNotNull:适用于不变量断言("这里逻辑上不可能为 null,如果为 null 说明有 bug")。优于!!的三点:带 contract(支持智能转换)、语义化异常类型、可携带上下文信息。- 自定义 contract 函数:适用于领域特定的校验(
isValid、asNonNull),让编译器理解你的领域不变量。 - (进阶)类型重设计:用 sealed class 表达"缺失的原因",用
value class表达"已验证的值"(第 7 章)。这是根治手段。
工程配套:Detekt 开启 UnsafeCallOnNullableType + allWarningsAsErrors,CI 拦截。
9.15 面试题精选
Q1:Kotlin 的 Lambda 和 Java 的 Lambda 在实现上有什么区别?
答题框架:
- 相似:都可以用
invokedynamic+LambdaMetafactory,运行时生成隐藏类。 - Kotlin 独有能力:
inline:把 Lambda 体复制到调用点,彻底消除对象分配与装箱——Java 没有对应机制(Java 的 Lambda 一定会生成 CallSite);reified类型参数:内联后类型信息保留,可以is T、T::class——Java 做不到;- 非局部返回 /
break/continue(📌 2.2 稳定)——Java 的 Lambda 只能return自身; - 契约:
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 设计的新工具。