04.8.1.4 集合、序列、作用域函数与 Java 互操作
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.1 语言核心与类型系统
本节要解决的问题
本节覆盖 Kotlin 只读/可变集合模型、Sequence 惰性链、五个作用域函数的选型与返回值,以及与 Java 互操作时的平台类型、注解映射、函数类型转换与受检异常行为。版本基线为 Kotlin 2.x、JDK 17+;版本行为不确定处标注「待确认」并给出验证点。
04.8.1.4-001 Kotlin 集合接口体系由哪些类型组成?
一句话结论
顶层 Collection<E> 派生 List<E> 与 Set<E>,Map<K, V> 是键值独立体系;每个只读接口对应可变接口 MutableList、MutableSet、MutableMap。
概念解释
Kotlin 把只读视图与可变实现拆成两套接口。Collection 定义尺寸、包含、迭代等基础能力;List 有序可重复,Set 去重,Map 按键存取值。接口只读不代表底层不可变,见后续题目。
原理流程
Collection声明通用集合能力。List/Set继承 Collection 并约束顺序与重复规则。Mutable*接口追加写入、删除、替换方法。- 工厂函数返回对应接口的实现实例。
代码或图示
val list: List<String> = listOf("a", "b")
val set: Set<Int> = setOf(1, 2, 2)
val map: Map<String, Int> = mapOf("x" to 1)
常见误区
- 把只读接口与不可变集合混为一谈:接口限制调用方写法,底层实现仍可能可变。
- 以为 Map 继承 Collection:Map 是独立键值体系。
追问
- 答:只读集合接口型变如何标注?答:
List<out E>协变生产者,MutableList<T>不变可变。 - 答:标准库实现类有哪些?答:ArrayList、LinkedList、LinkedHashSet、LinkedHashMap 等,具体以标准库为准。
04.8.1.4-002 只读集合与可变集合视图如何区分?
一句话结论
List<T>/Set<T>/Map<K,V> 暴露读取方法,MutableList<T> 等追加写入方法;引用类型决定调用方能否通过接口修改,底层对象可同时被可变引用持有。
概念解释
视图区分是编译期约束:只读引用不能调用 add/set,但同一底层实例可能被可变引用修改。需要真正不可变时使用工厂返回的只读实现并避免泄露可变引用。
原理流程
- 声明只读类型变量引用底层集合。
- 只读接口方法表无写入操作。
- 可变接口引用可调用 add/remove/set。
- 两处引用指向同一实例时,修改互相可见。
代码或图示
val mutable = mutableListOf(1, 2)
val readOnly: List<Int> = mutable
mutable.add(3)
println(readOnly.size) // 3,底层被可变引用修改
常见误区
- 以为
listOf返回的对象绝对不可被修改:它不暴露写入方法,但同一实例可被其他可变引用改动。 - 公开只读视图时泄露内部可变集合引用:外部虽不能经接口改,引用仍可被强转/共享。
追问
- 答:如何获得安全的不可变快照?答:复制为新只读集合,或封装在对象内只暴露只读视图且不泄露内部引用。
- 答:MutableList 与 List 是子类型关系吗?答:
MutableList<T>实现List<T>,可赋给只读引用。
04.8.1.4-003 listOf/mutableListOf 返回什么实际实现类型?
一句话结论
listOf 返回标准库只读 List 实现(通常基于 ArrayList 包装),mutableListOf 返回可变 ArrayList 实现;具体实现类以标准库版本为准,业务代码应面向接口编程。
概念解释
工厂函数隐藏实现细节,调用方按 List/MutableList 接口使用。不同元素数量与空集合可能使用优化实例;不要在业务代码中依赖具体实现类名。
原理流程
- 工厂函数按参数创建底层实现。
- 空集合返回优化实例。
- 非空集合按标准库策略选择实现。
- 外部通过接口方法访问。
代码或图示
val a = listOf("x", "y")
val b = mutableListOf(1, 2, 3)
常见误区
- 反射断言返回具体 ArrayList 类型:实现可能随版本调整。
- 把可变工厂结果赋给只读类型后又需要修改:应保留可变引用。
追问
- 答:空集合有必要复用吗?答:标准库空集合通常共享优化实例,业务中
emptyList()表达空值语义。 - 答:
setOf/mapOf同理吗?答:同理,返回对应只读接口实现。
04.8.1.4-004 为什么只读集合接口不保证底层不可变?
一句话结论
只读接口只限制调用方可见的方法集合,不复制底层数据;同一实例可被可变引用、内部封装或后续修改影响,因此「只读」是视图约束而非深度冻结。
概念解释
JDK 不可变集合(如 List.of)在实现层拒绝修改;Kotlin 只读接口主要是类型层视图。工程中需要防外部误改时,应封装内部可变状态并暴露只读视图,必要时复制快照。
原理流程
- 底层集合对象创建后可被修改。
- 只读引用只暴露读取方法。
- 可变引用或对象内部方法可改底层。
- 只读引用观察到底层变化。
代码或图示
class Cart {
private val items = mutableListOf<String>()
fun all(): List<String> = items // 只读视图,内部可变
fun add(item: String) { items.add(item) }
}
常见误区
- 把只读参数当作外部不可变契约写入文档。
- 暴露内部可变集合引用却不加封装:外部可通过共享引用改值。
追问
- 答:Kotlin 有没有类似 JDK
List.of的不可变实现?答:标准库只读实现按版本策略提供,不可变性保证程度需核对官方文档(待确认)。 - 答:跨线程发布集合注意什么?答:只读视图不能替代并发安全,共享可变状态需同步或并发容器。
04.8.1.4-005 可变集合提供哪些写操作方法?
一句话结论
MutableList/MutableSet/MutableMap 提供 add、addAll、remove、removeAll、retainAll、clear、set(List)、put/remove(Map)等修改方法。
概念解释
写操作改变底层集合状态,返回值通常表示是否发生变化。List 支持按下标 set;Map 按键 put、remove;Set 按元素增删。批量操作基于集合内容比较。
原理流程
- 单元素添加:add/put。
- 批量添加:addAll/putAll。
- 删除:remove/removeAll/clear。
- 保留交集:retainAll;List 下标替换:set。
代码或图示
val m = mutableListOf(1, 2)
m.add(3)
m.addAll(listOf(4, 5))
m.remove(2)
m[0] = 10
val map = mutableMapOf("a" to 1)
map["b"] = 2
常见误区
- 在只读 List 引用上调 add:编译报错。
- 忽略写操作返回值:元素是否真的被改变需要判断返回。
追问
- 答:
removeIf一类条件删除在哪?答:标准库集合扩展提供条件移除方法,签名以版本为准。 - 答:可变集合修改影响只读视图吗?答:同一实例互相可见,见只读视图题目。
04.8.1.4-006 集合工厂函数与空集合 emptyList 如何使用?
一句话结论
listOf/setOf/mapOf 按参数创建集合,无参形式返回空集合;emptyList()/emptySet()/emptyMap() 显式表达空集合语义,类型由目标上下文推断。
概念解释
空集合是合法非空集合引用,可遍历、判空;与 null 语义不同。工厂函数返回只读接口,需要可变实例用 mutable*Of。
原理流程
- 有参工厂按元素创建集合。
- 无参工厂返回共享空实例。
emptyXxx()显式标注空集合意图。- 目标类型推断元素/键值类型。
代码或图示
val none: List<String> = emptyList()
val tags = setOf("kotlin", "jvm")
val config: Map<String, String> = emptyMap()
常见误区
- 用
null表示空集合:遍历处反复判空。 - 空集合引用误当可空:空集合不是
null。
追问
- 答:空集合与 null 分别用于什么?答:空集合表示已加载且无元素;null 表示值缺失/未加载。
- 答:
listOf()与emptyList()区别?答:语义等价,后者更明确表达空集合意图。
04.8.1.4-007 集合元素可空性与集合本身可空性有什么区别?
一句话结论
外层 ? 表示集合引用可空,内层类型 ? 表示元素可空;两层独立判断,访问时先判容器再处理元素空值。
概念解释
List<String?> 集合存在、元素可为空;List<String>? 集合引用可为空、元素非空;List<String?>? 两层都可空。类型后缀位置决定语义层级。
原理流程
- 外层可空:调用集合方法前安全调用
?.。 - 内层可空:遍历元素后判空或过滤。
- 组合类型两层约束叠加。
- 不可混淆两层
?位置。
代码或图示
var elements: List<String?> = listOf("a", null)
var holder: List<String>? = null
var both: List<String?>? = null
常见误区
- 只判容器空就直接使用元素:元素仍可能为 null。
- 把元素可空写成容器可空:语义错位。
追问
- 答:
filterNotNull处理哪一层?答:剔除元素空值,不处理容器引用空值。 - 答:泛型参数默认上界是什么?答:
Any?,允许元素可空实参。
04.8.1.4-008 List 与 Array 有什么区别?
一句话结论
List 是集合接口,元素可增删遍历,元素装箱存储;Array 是固定长度容器,有专用原始类型数组,长度创建后不可变,支持下标直接读写。
概念解释
List 业务操作丰富(map/filter/分组等),Array 贴近 JVM 数组语义。原始类型数组(IntArray)连续存储无包装对象;Array<T> 是引用数组。
原理流程
- List:可变/只读接口,元素数量可变化。
- Array:长度固定,下标访问。
- 原始数组按基础类型连续存储。
- 两者可通过转换方法互转。
代码或图示
val list = listOf(1, 2, 3)
val arr = intArrayOf(1, 2, 3)
val generic: Array<String> = arrayOf("a", "b")
常见误区
- 用 Array 承载业务元素操作:缺少集合扩展方法。
- 混淆 IntArray 与 Array
:前者原始连续存储,后者引用包装。
追问
- 答:List 与 Array 如何互转?答:
toList()、toTypedArray()、toIntArray()等标准库方法。 - 答:数组长度可变吗?答:Array 长度固定,扩容需创建新数组复制。
04.8.1.4-009 Kotlin 数组类型与字面值如何书写?
一句话结论
专用数组类型 IntArray、LongArray、DoubleArray、BooleanArray、CharArray 等对应原始类型;泛型数组 Array<T> 用 arrayOf 创建,字面值按类型工厂生成。
概念解释
原始数组映射 JVM 原始类型数组,元素无装箱;Array<T> 元素为引用。数组工厂函数名与类型对应,下标访问与长度属性与其他语言数组一致。
原理流程
- 原始类型工厂创建专用数组。
- 引用类型工厂创建泛型数组。
- 下标读写
arr[i]。 size属性返回长度。
代码或图示
val nums = intArrayOf(10, 20)
val words = arrayOf("Kotlin", "JVM")
println(nums[0])
println(words.size)
常见误区
- 把
Array<Int>当原始数组使用:元素装箱。 - 数组越界不做范围检查:运行时抛下标越界异常。
追问
- 答:字符串数组与字符数组区别?答:
Array<String>存字符串引用,CharArray存字符原始值。 - 答:数组互操作见哪题?答:本节 Java 互操作部分 IntArray 与 Array
映射。
04.8.1.4-010 可变集合在 Java 互操作时有什么平台类型风险?
一句话结论
Java 集合签名未标注空性时,Kotlin 侧得到平台类型集合:集合本身与元素可空性未知,直接解引用或假定非空可能触发 NPE。
概念解释
Java List 返回值在 Kotlin 中呈现为 List! 平台类型。既可被当作可空也可被当作非空使用,空值假设错误时崩溃出现在 Kotlin 调用点。
原理流程
- 解析 Java 方法签名,无空性注解。
- 生成平台类型集合。
- 赋给非空变量:编译器放行但运行时空检查。
- 为空时解引用抛 NPE。
代码或图示
// Java: List<User> listUsers()
val users: List<User> = javaService.listUsers() // 平台类型,内部可能为 null
常见误区
- 假定 Java 集合永不为空:未标注边界不可靠。
- 把平台集合元素直接当非空使用:元素也可能为 null。
追问
- 答:防御写法是什么?答:适配层声明可空集合,安全调用与校验后再使用。
- 答:哪些注解帮助确定空性?答:
@Nullable/@NotNull一类空性注解,支持范围以编译器为准。
04.8.1.4-011 toList/toMutableList 的复制语义是什么?
一句话结论
toList 复制元素生成新只读 List,toMutableList 生成新可变 List;复制后新旧容器独立,元素引用本身按引用共享。
概念解释
复制是浅拷贝:容器结构独立,元素引用不复制。可变元素对象修改仍会互相可见;需要深拷贝需单独复制元素。
原理流程
- 遍历源容器元素。
- 写入新容器实例。
- 新旧容器增删互不影响。
- 元素引用指向同一对象。
代码或图示
val source = mutableListOf(1, 2)
val copy: List<Int> = source.toList()
val mutableCopy = source.toMutableList()
source.add(3)
println(copy.size) // 2
常见误区
- 以为 toList 是深拷贝:元素引用共享。
- 复制后修改可变元素:两处观察到同一对象状态。
追问
- 答:何时需要复制?答:对外发布快照、避免内部可变状态泄露、隔离操作链。
- 答:
toSet/toMap同理吗?答:同理生成新容器,元素引用共享。
04.8.1.4-012 集合转换链的即时执行与 Sequence 惰性执行有何区别?
一句话结论
普通集合链每个中间操作生成新集合,即时执行;Sequence 操作在末端触发时逐元素流过整条链,中间不产生集合副本。
概念解释
Iterable 链 map/filter 每步分配中间 List;Sequence 返回惰性序列,中间操作只记录步骤,末端操作才驱动遍历。数据量小即时链直观,大数据/无限流用 Sequence 减少分配。
原理流程
- 集合链:每步遍历输入生成新集合。
- Sequence:中间操作返回新序列,保存步骤。
- 末端操作触发迭代,逐元素穿过所有步骤。
- 无中间集合副本,仅持有当前元素。
代码或图示
// 即时:filter 产生中间 List,再 map 产生新 List
val immediate = listOf(1, 2, 3).filter { it > 1 }.map { it * 2 }
// 惰性:末端 toList 时才逐元素计算
val lazy = listOf(1, 2, 3).asSequence().filter { it > 1 }.map { it * 2 }.toList()
常见误区
- 小数据链盲目用 Sequence:惰性调度有额外开销,未必更快。
- 以为 Sequence 改变元素处理结果:结果顺序与等价集合链一致。
追问
- 答:Sequence 中间操作有哪些?答:map、filter、take、distinct 等,末端操作触发求值。
- 答:何时互转?答:需要复用多次结果转 List;大流式处理用 Sequence 减少中间分配。
04.8.1.4-013 Sequence 的惰性求值模型如何工作?
一句话结论
Sequence 由一系列中间操作与末端操作组成;中间操作返回新序列并记录变换,末端操作启动迭代,元素逐个流经各步骤,末端才产出最终结果。
概念解释
惰性模型把「构建处理链」与「执行计算」分开。每个元素到达末端前经过全部中间步骤,中间不落地为集合;无限序列只能通过末端受限遍历消费。
原理流程
asSequence/sequenceOf生成初始序列。- 中间操作装饰出带步骤的新序列。
- 末端操作(toList、first、count 等)触发迭代。
- 逐元素执行步骤链并产出结果。
代码或图示
val seq = generateSequence(1) { it + 1 }
.filter { it % 2 == 0 }
.take(5)
.toList() // 末端触发,前 5 个偶数
常见误区
- 中间操作就期待结果:未末端执行时不计算。
- 对无限序列做无界末端操作(toList):永远遍历不完。
追问
- 答:Sequence 元素处理顺序?答:单元素穿过整条链,再处理下一元素,与等价集合链结果一致。
- 答:Sequence 可以多次末端遍历吗?答:默认序列一次性遍历约束见后续题目。
04.8.1.4-014 Sequence 与集合链在内存和时间上如何对比?
一句话结论
集合链为每步分配中间集合,大数据量下堆分配与复制成本高;Sequence 不产生中间容器,内存占用低,但每元素调度有额外开销,小数据可能更慢。
概念解释
选型看数据规模与链路长度:短链小数据即时集合直观且快;长链、大集合、流式生成用 Sequence 降低中间分配。实测应对比分配量、耗时与最终内存。
原理流程
- 集合链:中间集合数量 = 操作步数,元素重复复制。
- Sequence:仅末端结果落地,过程持有当前元素。
- 惰性调度增加函数调用与迭代器开销。
- 数据规模越大,Sequence 内存优势越明显。
代码或图示
val big = (1..100_000).asSequence()
.map { it * 2 }
.filter { it % 3 == 0 }
.toList()
常见误区
- 宣称 Sequence 一定更快:小数据调度开销可能超过节省的分配。
- 忽略 Sequence 末端结果仍占内存:最终集合大小不变。
追问
- 答:如何测量对比?答:对比中间对象分配、GC 次数与链路耗时,使用大样本数据。
- 答:Sequence 适合哪些来源?答:文件行、生成序列、数据库流式结果等大或无限来源。
04.8.1.4-015 Sequence 有哪些生成方式?
一句话结论
可由 sequenceOf 直接生成、集合 asSequence() 转换、sequence { } 构建器 yield 产出元素,或 generateSequence 按迭代函数生成。
概念解释
不同来源对应不同工厂:有限固定元素用 sequenceOf,已有集合转视图用 asSequence,自定义生产逻辑用构建器,递推序列用 generateSequence。
原理流程
sequenceOf:固定元素序列。asSequence:包装已有集合为惰性视图。sequence { yield(value) }:构建器协程式产出。generateSequence(seed) { next }:按函数递推。
代码或图示
val s1 = sequenceOf(1, 2, 3)
val s2 = listOf("a", "b").asSequence()
val s3 = sequence { yield(1); yield(2) }
val s4 = generateSequence(0) { it + 2 }
常见误区
- 构建器里做重副作用却在中间阶段:未末端执行时不发生。
- generateSequence 缺少终止条件:无限序列需 take 限制。
追问
- 答:
yield如何暂停产出?答:构建器挂起点逐个产出元素,末端遍历恢复执行。 - 答:Sequence 构建器与标准库 buildList 区别?答:前者惰性序列,后者即时收集可变列表。
04.8.1.4-016 大集合或无限流场景如何选择 Sequence?
一句话结论
数据量大、链路长、来源流式或无限时用 Sequence 避免中间集合;结果需要多次复用、数据量小或需要随机访问时用普通集合。
概念解释
无限流必须用惰性序列配合 take/first 等有界末端;大文件/数据流逐段处理。若结果要反复遍历或按下标访问,Sequence 转集合更合适。
原理流程
- 评估数据规模与是否有限。
- 大/无限且链式处理:选 Sequence。
- 结果复用或随机访问:转 List。
- 末端操作必须有界,避免无限阻塞。
代码或图示
val lines = sequence {
// 逐行产出模拟
yield("line1"); yield("line2")
}.takeWhile { it.isNotBlank() }.toList()
常见误区
- 无限序列调用 toList:无法终止。
- 大集合链不加 asSequence:中间集合累积内存。
追问
- 答:Sequence 结果能否再次遍历?答:取决于序列类型,部分序列一次性消费,见后续题目。
- 答:数据库流式查询适配什么?答:按驱动返回的迭代/流包装为 Sequence 或直接消费迭代器。
04.8.1.4-017 Sequence 的中间操作与末端操作如何划分?
一句话结论
中间操作(map、filter、take、distinct 等)返回新 Sequence 不执行计算;末端操作(toList、first、count、reduce、forEach 等)启动迭代并产出结果。
概念解释
划分依据是返回类型:返回 Sequence 为中间,返回具体结果或 Unit 为末端。链中必须有末端操作才会实际计算;中间操作可继续装饰序列。
原理流程
- 初始序列来源。
- 中间操作记录变换步骤。
- 末端操作请求元素并驱动遍历。
- 计算结果在末端落地。
代码或图示
val r = sequenceOf(1, 2, 3)
.map { it + 1 } // 中间
.filter { it > 1 } // 中间
.toList() // 末端触发
常见误区
- 把
forEach当中间操作:它是末端消费。 - 链无末端操作:步骤不执行。
追问
- 答:
take是中间还是末端?答:中间操作,限制序列长度,返回新 Sequence。 - 答:末端操作返回什么?答:集合、单个元素、计数、布尔或 Unit 消费结果。
04.8.1.4-018 Sequence 的一次性遍历约束是什么?
一句话结论
部分 Sequence(尤其构建器与迭代器包装)只能遍历一次,第二次末端迭代可能为空或重新计算;需要复用结果应先转为集合。
概念解释
普通集合可多次遍历,序列基于迭代器消费后状态耗尽。不同序列来源行为可能不同,复用场景显式 toList() 固化结果最稳妥。
原理流程
- 首次末端遍历消费迭代器元素。
- 迭代器到达末尾后不可重置。
- 第二次遍历无元素或按来源重新生成。
- 多次使用先收集为 List。
代码或图示
val seq = listOf(1, 2, 3).asSequence()
val first = seq.toList()
// 再次遍历同一序列行为取决于来源;复用应先 toList 固化
常见误区
- 假设 Sequence 像 List 一样可反复遍历。
- 把同一 Sequence 传入多个末端操作:状态可能已耗尽。
追问
- 答:哪些序列可重复遍历?答:基于可重复集合的视图序列行为不同,具体以标准库实现为准(待确认)。
- 答:复用结果标准做法?答:末端
toList()后对集合多次操作。
04.8.1.4-019 Map 取值操作有哪些?
一句话结论
get(key) 与 [] 返回可空值,getOrElse 提供默认计算,getOrDefault 提供默认值;取值缺失返回 null 或默认值,不抛异常。
概念解释
Map 取值按键查找,不存在时各方法策略不同:[]/get 返回 null,getOrElse 用 lambda 计算缺省,getOrDefault 用固定默认值。键不存在不影响 Map 内容。
原理流程
- 按键哈希查找条目。
- 存在:返回关联值。
- 不存在:按方法返回 null、lambda 默认或固定默认。
- 写入用
put/[]=。
代码或图示
val cap = mapOf("a" to 1, "b" to 2)
println(cap["a"]) // 1
println(cap["missing"]) // null
println(cap.getOrElse("x") { 0 }) // 0
println(cap.getOrDefault("y", -1)) // -1
常见误区
- 把
[]返回值当非空使用:缺失返回 null。 - 用 getOrElse 做有副作用缺省:lambda 仅在缺失时求值。
追问
- 答:Map 取值与集合 firstOrNull 区别?答:按键查找 vs 按谓词遍历元素。
- 答:如何安全取值并处理 null 值?答:区分「键不存在」与「值为 null」,必要时用 containsKey 判断。
04.8.1.4-020 Map 构建与 Pair 语法如何使用?
一句话结论
mapOf(k1 to v1, k2 to v2) 用 to 中缀函数构造 Pair 条目;to 是 infix 扩展,返回 Pair<K, V>,Map 工厂按条目构建键值对。
概念解释
to 构造键值对,Map 工厂接收 Pair 列表。也可 associateWith/associate 从集合构建 Map;重复键按构建规则覆盖或保留。
原理流程
key to value生成 Pair。- mapOf 接收 Pair 序列。
- 按键去重,冲突按工厂规则处理。
- 返回只读 Map。
代码或图示
val colors = mapOf("red" to 0xFF0000, "blue" to 0x0000FF)
val byName = listOf("a", "b").associateWith { it.length }
常见误区
- 重复键期待全部保留:Map 键唯一,后值覆盖前值(按工厂规则)。
- 把 Pair 当 Map 直接使用:Pair 是二元组,需放入 Map 工厂。
追问
- 答:
to是中缀函数吗?答:是 infix 扩展函数,也可点号调用Pair.to(...)。 - 答:Map 解构条目怎么写?答:
for ((k, v) in map)按 Pair 组件解构。
04.8.1.4-021 Set 去重与元素相等性契约是什么?
一句话结论
Set 元素不可重复,判定依据元素 equals/hashCode;相等元素只保留一个,可变元素加入后修改会破坏去重与查找契约。
概念解释
哈希 Set 按哈希分桶再比较相等性。值对象(data class)按内容去重;可变对象加入 Set 后改字段,哈希变化导致元素无法找回。
原理流程
- 加入元素计算哈希定位桶。
- 桶内按 equals 比较。
- 相等则不重复加入,不等则追加。
- 查找与移除按相同契约。
代码或图示
val tags = setOf("kotlin", "jvm", "kotlin")
println(tags.size) // 2
data class User(val id: Long)
val users = setOf(User(1), User(1)) // 去重为 1 个
常见误区
- 可变元素入 Set 后修改字段:哈希与相等性失配。
- 依赖身份去重:Set 按内容相等性判断。
追问
- 答:HashSet 顺序有保证吗?答:哈希 Set 迭代顺序不保证;需要顺序用 LinkedHashSet。
- 答:自定义类型去重要实现什么?答:正确的
equals/hashCode契约。
04.8.1.4-022 LinkedHashSet/LinkedHashMap 的顺序语义是什么?
一句话结论
链表哈希集合/映射维护插入顺序,迭代按加入先后返回;哈希定位保证查找效率,链表记录顺序。
概念解释
与纯哈希实现不同,Linked 类型在哈希表外串联条目链表,插入顺序可预测。遍历、展示与需要顺序稳定的场景使用;元素重排不改变链表顺序。
原理流程
- 哈希表按键定位条目。
- 链表按插入顺序串联条目。
- 迭代沿链表返回。
- 移除条目同步解除链表链接。
代码或图示
val ordered = linkedMapOf("a" to 1, "b" to 2, "c" to 3)
println(ordered.keys.toList()) // [a, b, c]
常见误区
- 以为普通 HashSet/HashMap 保序:纯哈希实现顺序不保证。
- 依赖顺序做业务判断却用纯哈希实现:顺序不稳定。
追问
- 答:Kotlin 工厂返回哪种实现?答:
mutableMapOf/setOf实现类型以标准库版本为准,需要显式顺序可创建 Linked 实现。 - 答:访问顺序与插入顺序区别?答:LinkedHashMap 可按访问顺序模式,具体配置以 JVM 实现为准。
04.8.1.4-023 排序 sortedBy 与空值如何处理?
一句话结论
sortedBy 按选择器结果自然排序,sortedWith 接受 Comparator;空值在自然顺序中排前或按定制比较器置后,需显式规则处理。
概念解释
数字、字符串、Comparable 类型有自然顺序。可空元素默认比较规则可能把 null 置前;业务需要空值置后时自定义 comparator 或先过滤再排序。
原理流程
- 选择器提取可比较键。
- 自然顺序或定制比较器排序。
- 空值按比较器规则定位。
- 返回新排序集合,原集合不变。
代码或图示
val rows = listOf(3, null, 1, null, 2)
val sorted = rows.sortedWith(compareBy(nullsLast()) { it })
val names = listOf("Bob", "ann", "Carol").sortedBy { it.lowercase() }
常见误区
- 可空元素直接 sortedBy 不处理 null:顺序依赖默认规则。
- 排序忽略大小写:按原字符串大小写顺序不符合预期。
追问
- 答:多条件排序怎么做?答:
compareBy({ it.a }, { it.b })链式比较器。 - 答:排序返回新集合吗?答:集合排序生成新列表;可变集合
sort()原地排序。
04.8.1.4-024 分组 groupBy 与分区 partition 有什么区别?
一句话结论
groupBy 按键分组为 Map<K, List<T>>,支持多类别;partition 按谓词分为匹配与不匹配两个列表,结果是二元组。
概念解释
分组适用于多类别聚合,键由选择器生成;分区是二分法,true/false 两组。两者都不修改原集合,返回新集合结构。
原理流程
- 遍历元素提取分组键或谓词结果。
- groupBy 累积到 Map 对应列表。
- partition 累积到两个固定列表。
- 返回分组映射或二元组。
代码或图示
val words = listOf("a", "bb", "ccc")
val byLen = words.groupBy { it.length } // {1=[a], 2=[bb], 3=[ccc]}
val (short, long) = words.partition { it.length <= 1 }
常见误区
- 二分类场景用 groupBy:结果结构不如 partition 直接。
- 分组键返回可空:Map 键可为 null,注意处理。
追问
- 答:分组后如何聚合统计?答:分组值列表再 fold/reduce/count 聚合。
- 答:partition 顺序保持吗?答:两组内部保持原集合顺序。
04.8.1.4-025 reduce、fold、scan 的区别是什么?
一句话结论
fold 带初始值逐项累积,reduce 用首元素作为初始值;scan 保留每一步累积结果形成序列。三者都是聚合操作,返回类型与中间结果粒度不同。
概念解释
fold 初始值显式给出,空集合合法;reduce 无初始值,空集合抛异常。scan 产出累积过程列表,用于观察中间状态。
原理流程
- fold:初始值 → 逐项合并 → 最终累积值。
- reduce:首元素为初始值 → 逐项合并。
- scan:每步累积结果加入序列。
- 集合即时执行,Sequence 末端触发。
代码或图示
val nums = listOf(1, 2, 3)
val sum = nums.fold(0) { acc, x -> acc + x }
val product = nums.reduce { acc, x -> acc * x }
val running = nums.scan(0) { acc, x -> acc + x } // [0, 1, 3, 6]
常见误区
- 空集合调用 reduce:抛异常,应评估 fold 兜底。
- scan 误以为只返回最终值:它返回每步累积序列。
追问
- 答:fold 与 reduce 返回类型必须一致吗?答:reduce 要求元素类型与累积兼容;fold 可返回与元素不同的累积类型。
- 答:scan 与 running 聚合场景?答:计算前缀和、过程统计等需要中间结果的场景。
04.8.1.4-026 分组聚合与 flatten/flatMap 如何配合?
一句话结论
嵌套集合先用 flatten 拍平一层,flatMap 逐元素映射为集合再合并;分组后对各组列表聚合统计,组合使用完成多维数据处理。
概念解释
flatten 合并嵌套 List,flatMap 是映射 + 合并一步完成。分组聚合:groupBy 后遍历 Map 值做 count/sum/max 等统计。
原理流程
- 嵌套列表 flatten 拍平一层。
- flatMap 元素 → 集合 → 合并结果。
- groupBy 得到分组 Map。
- 各组列表聚合为统计结果。
代码或图示
val nested = listOf(listOf(1, 2), listOf(3))
val flat = nested.flatten()
val chars = listOf("ab", "cd").flatMap { it.toList() }
val stats = words.groupBy { it.first() }
.mapValues { (_, list) -> list.size }
常见误区
- flatten 只拍平一层:更深嵌套需多次 flatten 或 flatMap。
- 分组后直接聚合忽略空组:键集合按存在分组遍历。
追问
- 答:flatMap 与 map + flatten 等价吗?答:语义等价,flatMap 一步完成。
- 答:分组值聚合返回什么?答:mapValues 转换分组列表为统计值,得到新 Map。
04.8.1.4-027 索引操作有哪些方法?
一句话结论
indexOf/lastIndexOf 按元素查找下标,firstIndex/lastIndex 按谓词查找,elementAt 按下标取值,越界有 OrNull 变体。
概念解释
索引操作区分「找元素位置」与「按位置取元素」。List 支持下标访问,Set/Map 索引语义按各自结构;越界取值用 elementAtOrNull 避免异常。
原理流程
- 元素查找:遍历比较相等性返回首个/末个下标。
- 谓词查找:匹配条件返回下标。
- 下标取值:检查范围后返回元素。
- OrNull 变体越界返回 null。
代码或图示
val list = listOf("a", "b", "c", "b")
println(list.indexOf("b")) // 1
println(list.lastIndexOf("b")) // 3
println(list.firstIndex { it == "c" }) // 2
println(list.elementAtOrNull(10)) // null
常见误区
- 对无序 Set 用 indexOf:Set 下标语义不适用。
- 下标越界直接 elementAt:抛越界异常,优先 OrNull 兜底。
追问
- 答:
withIndex提供什么?答:遍历同时拿到索引与元素的解构条目。 - 答:Map 索引按键还是按下标?答:Map 按键查找值,无下标概念。
04.8.1.4-028 条件查找 find/firstOrNull/singleOrNull 与异常场景是什么?
一句话结论
find/firstOrNull 返回首个匹配,无匹配返回 null;singleOrNull 要求至多一个匹配,多个匹配返回 null;first/single 无匹配或多匹配时抛异常。
概念解释
查找方法分「宽容返回 null」与「严格抛异常」两类。业务可能无结果用 OrNull 变体;确定存在或唯一时用严格方法,失败即暴露数据问题。
原理流程
- 遍历元素匹配谓词。
- first 类:取首个匹配。
- single 类:统计匹配数量,唯一才返回。
- 无匹配/多匹配按方法返回 null 或抛异常。
代码或图示
val items = listOf(1, 2, 3)
items.firstOrNull { it > 2 } // 3
items.firstOrNull { it > 5 } // null
items.singleOrNull { it == 2 } // 2
// items.first { it > 5 } // 抛 NoSuchElementException
常见误区
- 用 single 检查可能多匹配的列表:多匹配返回 null 而非报错。
- 该兜底场景用严格方法:异常中断流程。
追问
- 答:
find与firstOrNull关系?答:find 是 firstOrNull 别名语义。 - 答:
single多匹配抛什么?答:IllegalArgumentException一类异常,具体类型以标准库为准。
04.8.1.4-029 谓词操作 all/none/any 如何使用?
一句话结论
all 判断全部元素满足谓词,none 判断全部不满足,any 判断存在至少一个满足;空集合按逻辑真空真/空真规则返回。
概念解释
布尔聚合短路求值:确定结果后不再遍历。空集合 all/none 为 true,any 为 false,符合逻辑量词规则。结果可用于校验与存在性判断。
原理流程
- 遍历元素应用谓词。
- all 遇不满足即返回 false。
- none 遇满足即返回 false。
- any 遇满足即返回 true;空集按量词规则返回。
代码或图示
val nums = listOf(2, 4, 6)
nums.all { it % 2 == 0 } // true
nums.none { it < 0 } // true
nums.any { it > 5 } // true
常见误区
- 空集合期待 any 为 true:空集 any 为 false。
- 忽略短路:谓词副作用不应依赖遍历完整性。
追问
- 答:谓词有副作用安全吗?答:短路可能不执行全部元素,副作用逻辑应独立。
- 答:any 与 firstOrNull 搭配?答:any 判断存在性,firstOrNull 取匹配值。
04.8.1.4-030 如何过滤集合中的空元素 filterNotNull?
一句话结论
filterNotNull 剔除集合内为 null 的元素,返回非空元素列表;它只处理元素可空性,不处理集合引用本身可空。
概念解释
输入 List<T?>,输出 List<T>。元素判空后收窄类型;容器为 null 时需先安全调用。与 filter 谓词相比,类型推断自动收窄元素类型。
原理流程
- 遍历元素判断是否为 null。
- 非空元素加入结果。
- 结果元素类型收窄为非空 T。
- 容器可空性由外层
?.处理。
代码或图示
val values: List<String?> = listOf("a", null, "b")
val nonNull: List<String> = values.filterNotNull()
常见误区
- 对可空容器调用 filterNotNull:仍需先判容器。
- 以为它过滤空字符串:只过滤 null,空字符串保留。
追问
- 答:过滤空白字符串用什么?答:
filter { it.isNotBlank() }。 - 答:filterNotNull 返回类型如何收窄?答:标准库签名返回
List<T>,编译器元素类型为非空。
04.8.1.4-031 类型过滤 filterIsInstance 与类型转换如何配合?
一句话结论
filterIsInstance<T> 保留类型匹配元素并收窄为 T;受类型擦除限制,只能判断外层类型,泛型容器元素实参无法区分。
概念解释
运行时按类实例判断,匹配元素强转为目标类型。reified 版本在编译期携带类型;非 reified 版本接收 KClass/Class 参数。擦除后 List<String> 与 List<Int> 无法区分。
原理流程
- 遍历元素检查类型归属。
- 匹配元素加入结果并强转。
- 不匹配跳过。
- 泛型实参类型擦除后不可判断。
代码或图示
val mixed: List<Any> = listOf(1, "two", 3L)
val ints: List<Int> = mixed.filterIsInstance<Int>()
常见误区
- 用 filterIsInstance 判断嵌套泛型实参:擦除受限。
- 未检查强转告警不说明安全前提:应基于实例判断。
追问
- 答:reified 与 KClass 版本区别?答:reified 编译期携带类型;普通版本显式传类对象。
- 答:类型不匹配元素去哪了?答:被过滤排除在结果外。
04.8.1.4-032 集合与序列在什么时机互转?
一句话结论
已有集合需要惰性链式处理时 asSequence();序列结果需要复用、随机访问或多次遍历时候 toList();不要在同一条链上反复互转。
概念解释
互转边界决定中间分配:集合进序列消除后续中间集合,序列出集合固化结果。频繁来回转换会抵消惰性收益并增加复制成本。
原理流程
- 大集合长链:先 asSequence 再链式处理。
- 末端结果固化:toList/toSet。
- 复用结果对集合多次操作。
- 避免链中 toList 后又 asSequence。
代码或图示
val result = source.asSequence()
.map { ... }
.filter { ... }
.toList()
常见误区
- 每步操作后 toList:退化为即时集合链。
- 序列结果继续多次遍历:先固化为集合。
追问
- 答:Sequence 转数组怎么做?答:
toTypedArray()/专用数组转换方法。 - 答:小数据需要转序列吗?答:短链小数据即时集合更直接。
04.8.1.4-033 五个标准作用域函数分别是什么?
一句话结论
let、run、with、apply、also 是标准库作用域函数,区别在接收者引用方式(it/this)与返回值(lambda 结果/对象本身)。
概念解释
作用域函数为临时作用域提供语法封装:配置对象、变换结果、穿插副作用。选型看两点:内部用 this 还是 it,返回对象本身还是 lambda 计算结果。
原理流程
- 函数接收接收者与 lambda。
- 绑定接收者为
this或参数it。 - 执行 lambda 体。
- 返回 lambda 结果或接收者对象本身。
代码或图示
// let: it,返回 lambda 结果
val n = name?.let { it.trim().length }
// apply: this,返回对象本身
val p = Person().apply { name = "Ann" }
常见误区
- 不区分返回值:链式调用拿到错误类型。
- 为用作用域函数而嵌套:可读性下降。
追问
- 答:作用域函数是扩展还是顶层函数?答:let/run/apply/also 为扩展形式,with 为顶层函数,详见各题。
- 答:作用域函数有运行时开销吗?答:基本是语法层调用封装,热点路径可实测对比。
04.8.1.4-034 作用域函数中 it 与 this 如何区分?
一句话结论
let/also 把接收者作为 lambda 参数,用 it 引用;run/with/apply 把接收者作为上下文 this,可省略 this 直接调用成员。
概念解释
it 是隐式单参数名,需要显式命名时可改名;this 是接收者上下文,成员访问可省略前缀。选择引用方式取决于内部写法习惯与消歧需要。
原理流程
- let/also:lambda 签名
(T) -> R,接收者为it。 - run/with/apply:lambda 为
T.() -> R,接收者为this。 - 成员访问按对应引用解析。
- 多接收者嵌套时用限定
this@类型消歧。
代码或图示
name.let { it.length } // it
person.run { name = "Ann" } // this 省略
person.apply { age = 30 } // this 省略
常见误区
- 在
this作用域里写this.member与it.member混用:风格不一致。 - 嵌套作用域不区分两个
this:成员解析到错误接收者。
追问
- 答:
it可以改名吗?答:可以显式声明参数名替代隐式it。 - 答:
this可以省略吗?答:在接收者作用域内调用成员可省略this.。
04.8.1.4-035 作用域函数返回值是对象本身还是 lambda 结果?
一句话结论
apply/also 返回接收者对象本身;let/run/with 返回 lambda 最后一行表达式结果。返回值类型决定链式调用下一步能做什么。
概念解释
返回对象本身适合初始化后继续传递对象;返回 lambda 结果适合在作用域内做变换并取结果。误用会导致链式下一步类型错误。
原理流程
- apply/also:执行后返回接收者
T。 - let/run/with:返回 lambda 表达式结果
R。 - 链式下一步按返回类型匹配方法。
- 需要对象继续配置用 apply,需要计算结果用 let/run。
代码或图示
val user = User().apply { name = "Ann" } // 返回 User
val len = user.name.let { it.length } // 返回 Int
常见误区
- apply 后期待拿到 lambda 计算值:返回的是对象本身。
- also 中做变换却返回旧对象:变换结果未带出。
追问
- 答:
also与apply返回值相同吗?答:都返回接收者对象;区别在引用方式与典型用途。 - 答:链式中间穿插副作用用哪个?答:also 返回对象本身,适合穿插日志/校验不改变主链类型。
04.8.1.4-036 let 的典型场景是什么?
一句话结论
let 以 it 引用接收者并返回 lambda 结果,典型用于安全调用后变换:?.let { } 非空才执行,内部把值映射为结果。
概念解释
let 适合「值存在则变换」的场景:空值跳过,非空分支做转换、校验或取值。返回 lambda 最后一行,类型由变换结果决定。
原理流程
- 接收者可空时先
?.判空。 - 非空进入 let lambda,
it为接收者。 - 内部执行变换并返回结果。
- 整体结果类型为可空(空分支为 null)。
代码或图示
val city: String? = user?.address?.city
val upper: String? = city?.let { it.trim().uppercase() }
常见误区
- 用 let 做对象配置初始化:配置应选 apply。
- let 内修改外部状态却返回无关值:职责不清。
追问
- 答:let 与 map 扩展区别?答:let 作用于单个接收者变换;map 遍历集合逐元素变换。
- 答:
?.let空分支结果是什么?答:null,整体类型为 lambda 结果的可空形式。
04.8.1.4-037 run 的典型场景是什么?
一句话结论
run 以 this 为接收者执行 lambda 并返回结果,适合在对象上调用多个成员后取计算结果;与 let 相比引用方式为 this。
概念解释
run 既可作为扩展函数,也可配合 ?.run 安全调用。内部直接访问成员,返回表达式结果。需要配置对象本身继续传递时选 apply,需要计算结果选 run。
原理流程
- 接收者作为
this传入 lambda。 - 内部调用成员、做计算。
- 返回 lambda 最后一行结果。
- 空接收者配合
?.跳过。
代码或图示
val length = profile?.run { address.city.length }
val total = cart.run { items.sumOf { it.price } }
常见误区
- run 内只做配置不返回值:与 apply 场景混淆。
- 把 run 当链式副作用穿插:also 更合适。
追问
- 答:run 与 with 区别?答:run 是扩展函数可安全调用;with 是顶层函数,需显式传接收者。
- 答:run 返回对象本身吗?答:返回 lambda 结果,不是接收者本身。
04.8.1.4-038 with 的典型场景是什么?
一句话结论
with(接收者) { } 非扩展形式把对象作为 this 传入,集中调用一组成员,返回 lambda 结果;适合对同一对象执行多条语句的分组操作。
概念解释
with 不支持 ?. 链式安全调用,调用前需确认对象非空。内部省略 this 访问成员,把相关操作聚合在一个块内。
原理流程
- 显式传入接收者对象。
- lambda 内
this绑定该对象。 - 多条成员调用集中书写。
- 返回 lambda 表达式结果。
代码或图示
val report = with(user) {
"name=$name, age=$age"
}
常见误区
- 对可空对象直接 with:无安全调用保护。
- with 块内混入无关对象操作:作用域混乱。
追问
- 答:with 与 run 如何选?答:需要链式
?.安全调用选 run;已有非空对象集中写一组调用用 with。 - 答:with 返回值规则?答:返回 lambda 最后一行,不返回接收者本身。
04.8.1.4-039 apply 的典型场景是什么?
一句话结论
apply 以 this 配置对象并返回对象本身,典型用于对象初始化:构造后设置属性、注册回调,链式继续传递同一对象。
概念解释
apply 不返回计算结果,返回配置好的接收者。适合「创建即配置」的场景:属性赋值、监听器挂载、初始状态设置。
原理流程
- 创建对象实例。
- apply 把实例作为
this传入。 - 块内设置属性与状态。
- 返回原实例,可继续链式传递。
代码或图示
val dialog = Dialog().apply {
title = "Confirm"
message = "Are you sure?"
onCancel = { dismiss() }
}
常见误区
- apply 内做计算并期待返回结果:返回的是对象本身。
- 替代构造器默认值:简单属性优先构造参数默认值。
追问
- 答:apply 与构造注入如何取舍?答:必填依赖用构造器注入;可选配置与回调在 apply 中装配。
- 答:apply 修改的是原对象吗?答:是的,直接配置传入的实例,返回同一对象。
04.8.1.4-040 also 的典型场景是什么?
一句话结论
also 以 it 引用接收者、返回对象本身,典型用于链式穿插副作用:日志、校验、注册、调试,不改变主链返回类型。
概念解释
also 不替代变换,而是在链路中间插入不影响结果对象的动作。返回原接收者,后续链式继续操作同一对象。与 apply 区别在引用方式与用途侧重。
原理流程
- 链式主链得到对象。
- also 传入对象为
it。 - 块内执行副作用动作。
- 返回原对象,主链类型不变。
代码或图示
val order = createOrder()
.also { log.info("created ${it.id}") }
.also { validate(it) }
常见误区
- also 内修改变换主值:应放在变换步骤。
- 用 also 替代配置初始化:apply 更贴合 this 配置场景。
追问
- 答:also 与 let 区别?答:also 返回对象本身,let 返回 lambda 结果。
- 答:副作用放 also 还是单独语句?答:链式内穿插用 also;独立逻辑语句更清晰时单独写。
04.8.1.4-041 五个作用域函数的选型决策表是什么?
一句话结论
按两个维度选型:引用 this(run/with/apply)还是 it(let/also);返回对象本身(apply/also)还是 lambda 结果(let/run/with)。
概念解释
决策顺序:先确定返回值需求,再确定引用方式。配置对象返回自身 → apply;穿插副作用返回自身 → also;非空变换取结果 → let;对象上计算结果 → run;集中调用一组成员 → with。
原理流程
- 是否需要返回对象本身:是 → apply/also;否 → let/run/with。
- 内部用 this 还是 it:this → run/with/apply;it → let/also。
- 是否需要链式安全调用:let/run 支持
?.,with 不支持。 - 按场景确定最终函数。
代码或图示
返回对象本身:apply(this 配置) / also(it 副作用)
返回 lambda 结果:let(it 变换) / run(this 计算) / with(this 集中调用)
常见误区
- 只记函数名不看返回值与引用方式:链式类型出错。
- 同一职责在多个作用域函数间反复横跳:代码风格不统一。
追问
- 答:最易混淆的一对?答:apply 与 also 都返回对象本身,区别是 this 配置 vs it 副作用。
- 答:可空接收者首选哪个?答:
?.let做非空变换最常见。
04.8.1.4-042 作用域函数返回值如何影响链式调用?
一句话结论
返回对象本身的函数(apply/also)保持链式对象类型;返回 lambda 结果的函数(let/run/with)把链类型切换为结果类型,下一步只能调用结果类型方法。
概念解释
链式下一步可用方法由上一步返回类型决定。误用返回值会导致后续方法不存在或类型不匹配;阅读链式代码先标注每步返回类型。
原理流程
- apply/also 输出接收者类型 T。
- let/run/with 输出 lambda 结果类型 R。
- 链式下一步按输出类型解析方法。
- 类型不兼容编译报错。
代码或图示
// apply 后仍是 User,可继续访问 User 成员
val u = User().apply { name = "x" }.also { log(it) }
// let 后是 String,下一步只能调 String 方法
val s: String = user.let { it.name }
常见误区
- apply 后期待取 lambda 内计算值:拿不到。
- also 中返回变换结果:被忽略,主链仍是原对象。
追问
- 答:链式中需要先配置再取值怎么做?答:apply 配置对象,下一步用 run/let 取计算结果。
- 答:返回 Unit 的 lambda 影响类型吗?答:链类型变为 Unit,后续不能访问原对象成员。
04.8.1.4-043 作用域函数如何与空安全 ?.let 组合?
一句话结论
?.let { } 仅在接收者非空时进入 lambda,空值跳过并整体为 null;是可空值安全变换最常用组合,内部 it 已收窄为非空类型。
概念解释
安全调用 + let 把判空与变换合并:非空分支处理值,空分支自然兜底为 null。需要默认值时外层再叠 ?:。
原理流程
- 接收者为 null:短路,表达式结果 null。
- 非空:进入 let,it 类型收窄非空。
- lambda 返回变换结果。
- 整体类型为结果可空形式。
代码或图示
val display: String? = nickname?.let { it.trim().uppercase() }
val fallback: String = nickname?.let { it.trim() } ?: "guest"
常见误区
- 省略
?.直接 let 可空值:内部 it 仍可空。 - 把
?.let当 if-not-null 语句滥用:单步变换更清晰。
追问
- 答:
?.run与?.let区别?答:引用方式 this/it,返回值同为 lambda 结果。 - 答:非空校验后仍想断言非空怎么做?答:let 内已收窄,必要时
!!或 requireNotNull 兜底。
04.8.1.4-044 嵌套作用域函数如何消歧 this/it?
一句话结论
嵌套块存在多个接收者时,内层 this 指向最近接收者;访问外层用 this@外层类型 限定,it 按最近 lambda 参数解析,必要时显式命名参数。
概念解释
多层 DSL 或嵌套配置容易出现两个 this。解析顺序由内向外,歧义时显式限定。把外层接收者存入命名变量是最稳妥的消歧方式。
原理流程
- 外层块绑定接收者 A。
- 内层块绑定接收者 B。
- 成员查找先匹配 B,再沿链找 A。
- 限定
this@A或保存 A 引用访问外层。
代码或图示
class Page { fun title() {} }
class Section { fun body() {} }
page {
this@Page.title()
section {
this@Section.body()
}
}
常见误区
- 嵌套不显式限定:成员误解析到内层接收者。
- 把外层对象存成短名变量却与内层 this 混淆。
追问
- 答:DslMarker 与 this 消歧关系?答:标记屏蔽外层隐式访问,进一步减少跨层误调用。
- 答:it 重名如何避免?答:显式声明 lambda 参数名替代隐式 it。
04.8.1.4-045 过度使用作用域函数有哪些可读性反例?
一句话结论
多层嵌套作用域函数、为单步操作套块、作用域内混入无关逻辑,都会提升理解成本;作用域函数应服务于分组与安全变换,而非语法炫技。
概念解释
反例:三层 let/run 嵌套、apply 内做复杂计算、链式上串联多个无意义 also。评审时应判断去掉作用域块后代码是否更直接。
原理流程
- 识别作用域块是否承担分组/安全/配置职责。
- 单步变换可直接表达式书写。
- 副作用穿插优先独立语句。
- 嵌套层级控制在必要范围。
代码或图示
// 反例:过度嵌套
val x = a?.let { b?.run { c?.apply { /* ... */ } } }
// 更直接:分步取值与判空
val bVal = a?.b ?: return
常见误区
- 团队风格强制每个对象都套作用域函数。
- 作用域块内修改多个外部变量:副作用隐蔽。
追问
- 答:判断作用域函数是否必要的标准?答:去掉后代码是否更易读,职责是否更清晰。
- 答:apply 滥用典型表现?答:构造器默认值能解决的配置也塞进 apply。
04.8.1.4-046 Kotlin 调用 Java 集合时的平台类型 List! 是什么?
一句话结论
Java 集合签名未标注空性时,Kotlin 侧得到平台类型 List!:空性未知,可按可空或非空使用,空值假设错误时在解引用点抛 NPE。
概念解释
平台类型是跨语言边界的宽松类型,不能在 Kotlin 源码显式写出。集合本身与元素空性都可能未知,需要在适配层显式收口。
原理流程
- 解析 Java 方法/字段签名。
- 无空性注解 → 生成平台类型。
- 赋给非空变量:编译放行,运行时空检查。
- 为空解引用抛 NPE。
代码或图示
// Java: List<Order> findOrders()
val orders: List<Order> = service.findOrders() // List! 平台类型
常见误区
- 假定平台集合永不为空:边界无契约保证。
- 把平台类型当确定可空类型直接判空:类型推断宽松。
追问
- 答:平台类型与可空类型区别?答:平台类型空性未知,可空类型是确定可空。
- 答:如何收口?答:适配层声明
List<T>?,安全调用与校验后再使用。
04.8.1.4-047 Java 集合方法签名如何影响 Kotlin 可空性推断?
一句话结论
Kotlin 读取 Java 签名上的空性注解确定非空/可空;无注解则为平台类型。参数、返回值、字段与泛型实参位置分别映射,元素空性独立判断。
概念解释
注解在哪个位置就约束哪一层。返回 List<@Nullable User> 表示元素可空;方法返回值本身空性由返回位置注解决定。层级标注缺失会留下平台类型。
原理流程
- 读取方法返回、参数、字段注解。
- 明确注解映射为确定类型。
- 缺失位置生成平台类型。
- 泛型实参按其位置注解独立判断。
代码或图示
@Nullable List<@NotNull Item> getItems();
// Kotlin: 返回 List<Item>?,元素 Item 非空(按注解映射)
常见误区
- 只看集合外层注解忽略元素注解:元素空性误判。
- 注解冲突时凭经验选非空:证据不足应按可空兜底。
追问
- 答:常见空性注解有哪些?答:JetBrains、JSR-305 等
@Nullable/@NotNull,支持范围以编译器为准。 - 答:平台集合元素可能为 null 怎么处理?答:filterNotNull 或元素级判空。
04.8.1.4-048 Java 原始类型与包装类型在 Kotlin 侧如何映射?
一句话结论
Kotlin 非空基本类型优先映射 JVM 原始类型,可空与泛型容器退化为包装类;与 Java 互操作时按签名期望生成装箱/拆箱指令。
概念解释
Int ↔ int/Integer,Long ↔ long/Long,Boolean ↔ boolean/Boolean。映射位置由可空性与使用场景决定,跨边界注意装箱成本。
原理流程
- 非空局部/参数/返回值:原始类型。
- 可空声明:包装类。
- 泛型容器元素:包装类。
- 跨语言调用按 Java 签名转换。
代码或图示
fun add(a: Int, b: Int): Int = a + b // 原始 int
fun boxed(x: Int?): Int? = x // 装箱 Integer
常见误区
- 以为 Kotlin 基本类型总是对象:非空场景优先原始类型。
- 高频创建可空数字变量忽略装箱成本。
追问
- 答:Kotlin
==对装箱数字比较什么?答:比较数值内容,===才比较身份。 - 答:字符映射什么?答:
Char↔char/Character。
04.8.1.4-049 Java 方法返回数组或集合有什么防御性拷贝问题?
一句话结论
Java 方法直接返回内部可变集合引用时,外部可绕过类方法修改内部状态;Kotlin 侧拿到引用应判断是否需要复制快照,不默认返回值不可变。
概念解释
防御性拷贝是封装原则:内部可变状态不泄露原始引用。Java 历史代码常直接返回字段集合,Kotlin 适配层按需 toList/toMutableList 复制隔离。
原理流程
- Java 方法返回内部集合引用。
- Kotlin 外部持有同一引用。
- 外部修改影响 Java 对象内部状态。
- 需要隔离时复制为新集合。
代码或图示
// Java 直接返回内部 List
val external: List<String> = javaBean.getItems()
val snapshot: List<String> = external.toList() // 需要隔离时复制
常见误区
- 把 Java 返回集合当作不可变快照使用。
- 频繁复制大集合:评估是否在 Java 侧补防御性拷贝更合适。
追问
- 答:Kotlin 封装内部集合怎么暴露?答:私有可变字段 + 公开只读视图,必要时返回复制。
- 答:跨线程共享集合注意什么?答:只读视图不替代并发安全,可变状态需同步。
04.8.1.4-050 调用 Java 重载与 Kotlin 默认参数如何对应?
一句话结论
Kotlin 默认参数在 Java 侧不自动生成重载构造器/方法;需要 @JvmOverloads 注解才按默认值数量生成多个 Java 可见重载签名。
概念解释
Kotlin 源码可用命名参数省略默认值,Java 调用方只看到主签名。@JvmOverloads 标注在构造器或方法上,编译器生成递减参数的重载供 Java 使用。
原理流程
- Kotlin 声明带默认值参数。
- 加
@JvmOverloads。 - 编译器按默认位置生成重载方法/构造器。
- Java 按参数数量选择重载。
代码或图示
@JvmOverloads
fun greet(name: String, prefix: String = "Hello") = "$prefix, $name"
// Java 可见:greet(String) 与 greet(String, String)
常见误区
- 不加注解期待 Java 看到默认重载:Java 只能调全参签名。
@JvmOverloads与既有 Java 重载签名冲突:编译报重复方法。
追问
- 答:
@JvmOverloads能标注伴生对象方法吗?答:可以,作用于构造器与方法,具体规则以文档为准。 - 答:默认值表达式在重载中如何处理?答:生成重载调用主签名并传入默认值表达式。
04.8.1.4-051 Kotlin 默认参数在 Java 侧的可见性规则是什么?
一句话结论
无 @JvmOverloads 时 Java 必须传全参;注解后按从右到左省略默认参数生成重载,调用方按实参数量匹配。
概念解释
默认参数是 Kotlin 语法层便利,JVM 签名本身不携带默认值。生成重载只是转发到主签名,默认值表达式在转发点求值。
原理流程
- 主签名保留全部参数。
- 注解生成省略尾部默认参数的重载。
- 重载内部调用主签名并补默认值。
- Java 侧按可见重载调用。
代码或图示
class User @JvmOverloads constructor(
val name: String,
val age: Int = 0,
val active: Boolean = true
)
常见误区
- 以为 Java 可以用命名参数:Java 无命名参数语法,靠重载适配。
- 默认参数非尾部位置:重载省略规则受限。
追问
- 答:
@JvmOverloads生成几个重载?答:按有默认值的尾部参数数量生成,具体以编译器实现为准。 - 答:与
@JvmName冲突吗?答:分别控制方法名与重载生成,可组合使用。
04.8.1.4-052 Kotlin 顶层函数在 Java 侧是什么包装类形态?
一句话结论
顶层函数编译到文件对应的包装类静态方法,类名由文件名与 @JvmName 规则决定;Java 通过该包装类调用,不是挂在某个业务类型上。
概念解释
Kotlin 没有 Java 工具类强制命名规则,文件级成员由编译器组织。理解包装类形态有助于排查 Java 调用、反射与堆栈问题。
原理流程
- 顶层函数写入源文件。
- 编译器生成文件包装类。
- 函数成为包装类静态方法。
@JvmName覆盖生成类名或方法名。
代码或图示
// StringUtils.kt
fun trimAll(s: String) = s.replace(" ", "")
// Java 侧通过生成的包装类静态调用,类名以编译产物为准
常见误区
- 猜测包装类名而不查编译产物。
- 把顶层扩展当作接收者类型成员写进 Java 文档。
追问
- 答:如何固定包装类名?答:文件级
@file:JvmName("...")。 - 答:顶层属性在 Java 侧形态?答:包装类字段/getter/setter 或
@JvmField暴露字段。
04.8.1.4-053 @JvmName 如何修改生成的类名或方法名?
一句话结论
@JvmName 可作用于文件级(改包装类名)或函数级(改方法名),解决 Kotlin 命名与 Java 调用习惯/混淆冲突。
概念解释
Kotlin 函数名可含语法习惯,Java 侧按生成名调用。注解在编译期改变字节码签名名称,源码名与 Java 可见名可以不同。
原理流程
- 文件级注解指定包装类名。
- 函数级注解指定静态方法名。
- 编译器按注解生成签名。
- Java 侧使用注解后的名称。
代码或图示
@file:JvmName("StringTools")
package utils
@JvmName("joinLines")
fun List<String>.join() = joinToString("\n")
常见误区
- 注解作用域写错:文件级与函数级不可混用。
- 改方法名后不更新 Java 调用方文档。
追问
- 答:
@JvmName能改类名吗?答:文件包装类名通过文件级注解,普通类名不由它改。 - 答:与
@JvmStatic组合?答:分别控制名称与静态形态,可同时使用。
04.8.1.4-054 @JvmField 暴露字段而非访问器有什么规则?
一句话结论
标注 @JvmField 的属性在 Java 侧暴露为公开字段,不生成 getter/setter;适用于公开只读常量或无需封装的属性,受属性类型与可变性约束。
概念解释
默认 Kotlin 属性生成访问器;@JvmField 跳过访问器直接暴露字段。不能用于有自定义 getter/setter、lateinit 之外受限场景,具体约束以编译器规则为准。
原理流程
- 属性标注
@JvmField。 - 编译器生成公开字段。
- Java 直接字段读写,不经过访问器。
- 封装与校验逻辑不能挂在该字段上。
代码或图示
class Config {
@JvmField val version: String = "1.0"
}
// Java: config.version 直接字段访问
常见误区
- 给需要校验/派生逻辑的属性加
@JvmField:访问器被跳过。 - 可变公开字段破坏封装:Java 侧可直接改写。
追问
- 答:
@JvmField与const val区别?答:const 编译期内联常量;JvmField 暴露运行时字段。 - 答:哪些属性不能用 JvmField?答:自定义访问器、委托属性等受限场景,具体以文档为准(待确认)。
04.8.1.4-055 @JvmStatic 与伴生对象互操作如何工作?
一句话结论
伴生对象成员默认是对象实例方法;@JvmStatic 额外生成静态方法/属性签名,Java 可通过类名直接调用,无需经过 Companion 对象。
概念解释
Kotlin 源码用类名访问伴生成员,字节码默认是伴生实例方法。注解在静态转发与实例方法间生成兼容签名,Java 两种调用形式都可见。
原理流程
- 伴生对象声明方法/属性。
- 标注
@JvmStatic。 - 编译器生成静态转发成员。
- Java 类名直接调用静态签名。
代码或图示
class Factory {
companion object {
@JvmStatic fun create(): Factory = Factory()
}
}
常见误区
- 不加注解期待 Java 类名调用:需经 Companion 对象。
- 对普通实例成员误用
@JvmStatic:语义不适用。
追问
- 答:
@JvmStatic能用于顶层函数吗?答:顶层函数本就是静态形态;注解主要作用于伴生对象成员。 - 答:静态方法与实例方法会重复生成吗?答:按注解生成额外静态转发,原对象方法形态保留。
04.8.1.4-056 @JvmRecord、值类与 Java 记录的现状如何?
一句话结论
Kotlin 与 Java record、值类的互操作支持随版本演进,具体注解可用性、生成签名与序列化兼容必须在项目版本实测,不编造版本号。
概念解释
Java record 是不可变数据载体,Kotlin data class/value class 是对应建模方式。跨语言映射、注解标记与框架支持在不同版本存在差异,属于待确认点。
原理流程
- 记录项目 Kotlin 与 JDK 版本。
- 查官方文档对 record 互操作的说明。
- 最小工程编译验证生成签名与框架反序列化。
- 不确定结论标注「待确认」与验证步骤。
代码或图示
// 待确认:目标版本 data class/value class 与 Java record 互操作注解与签名
// 验证点:编译产物签名、Jackson/ORM 反序列化结果
常见误区
- 把预览互操作特性写成稳定默认行为。
- 忽略框架版本与语言版本分别演进。
追问
- 答:官方参考在哪里?答:kotlinlang.org 互操作与数据类章节。
- 答:待确认清单应包含什么?答:版本号、注解名、生成签名、正反序列化结果。
04.8.1.4-057 Kotlin 如何处理 checked exception(受检异常)?
一句话结论
Kotlin 不强制声明受检异常,方法签名不 throws 清单;Java 调用方按 JVM 规则处理,Kotlin 代码可抛出任何异常而不在签名声明。
概念解释
受检异常是 Java 编译期约束,Kotlin 类型系统不延续。Kotlin 函数可以抛 IOException 等而不声明;Java 调用 Kotlin 方法时,异常处理按 Java 规则与签名可见性判断。
原理流程
- Kotlin 函数体抛异常无需 throws 声明。
- 字节码异常表按实际抛出记录。
- Java 侧调用时检查受检异常声明可见性。
- 未声明的受检异常在 Java 侧编译行为按编译器规则。
代码或图示
fun readFile(path: String): String {
// 可抛出 IOException,签名不声明 throws
return java.io.File(path).readText()
}
常见误区
- 以为 Kotlin 方法必须声明受检异常:无此约束。
- Java 调用方不处理可能抛出的受检异常:按 Java 编译规则核实。
追问
- 答:Kotlin 抛 Java 受检异常合法吗?答:合法,语言层不限制,运行时异常照常抛出。
- 答:互操作异常可见性以什么为准?答:编译器版本与 JVM 字节码异常表,不确定处实测。
04.8.1.4-058 Kotlin 抛出 Java 受检异常在调用侧是什么编译行为?
一句话结论
Kotlin 侧不强制捕获或声明;Java 调用 Kotlin 方法时,编译器按方法签名与异常表判断受检异常处理要求,未声明异常的处理行为需结合目标编译器确认。
概念解释
跨语言异常处理是双向边界:Kotlin 宽松,Java 严格。调用方语言决定编译期检查,Kotlin 抛出的异常类型在 Java 签名中可见性受注解与字节码影响。
原理流程
- Kotlin 函数抛出受检异常。
- 编译产物保留异常抛出信息。
- Java 调用方按规则检查是否需要捕获/声明。
- 行为不确定处标注待确认并实测。
代码或图示
fun load(): String {
throw java.io.IOException("network")
}
常见误区
- 把 Java 受检规则套到 Kotlin 源码:Kotlin 无声明要求。
- 忽略 Java 调用方编译限制:跨语言 API 文档应说明可能异常。
追问
- 答:Kotlin 有 throws 注解吗?答:语言层无受检声明;如需 Java 侧提示,按互操作文档核对可用注解(待确认)。
- 答:运行时异常两侧一致吗?答:RuntimeException 两侧都不强制处理。
04.8.1.4-059 注解互操作 @JvmSuppressWildcards/@JvmWildcard 如何使用?
一句话结论
@JvmSuppressWildcards 抑制导出签名中的通配符,@JvmWildcard 显式生成通配符;用于控制 Kotlin 型变在 Java 侧的泛型签名呈现。
概念解释
Kotlin 型变导出为 Java 通配符,部分 Java 框架或调用方要求固定实参签名。注解在类、方法、参数或类型位置调整通配符生成规则。
原理流程
- 编译导出 Java 签名时按型变生成通配符。
- Suppress 注解去除不必要通配符。
- Wildcard 注解显式标注通配符。
- 框架按固定签名解析类型。
代码或图示
interface Repo {
@JvmSuppressWildcards fun findAll(): List<String>
}
常见误区
- 通配符与框架泛型反序列化冲突时不加调整:签名不匹配。
- 注解位置写错:作用域不覆盖目标签名。
追问
- 答:注解可作用于哪些位置?答:类、函数、属性、参数等,具体语法以官方文档为准。
- 答:与型变声明冲突谁优先?答:注解在导出签名层覆盖,编译规则以编译器为准。
04.8.1.4-060 SAM 转换:Kotlin 函数类型如何传给 Java 单抽象方法接口?
一句话结论
传给 Java SAM 接口时,lambda 适配为接口实现实例;Kotlin 函数类型与 SAM 接口在互操作边界相互转换,无需手写匿名类。
概念解释
SAM(Single Abstract Method)转换在 Java 接口边界生效。lambda 参数类型由接口方法签名推断;Kotlin 自身函数类型优先,Kotlin 声明接口的 SAM 支持范围以版本为准。
原理流程
- 目标位置为 Java 单方法接口。
- lambda 按接口方法签名推断参数与返回。
- 编译器生成接口实现实例。
- 调用接口方法时执行 lambda 体。
代码或图示
// Java: interface OnClick { void onClick(); }
button.setOnClickListener { println("clicked") }
常见误区
- 多方法接口用 lambda:不满足 SAM 条件。
- 期待 Kotlin 接口无条件 SAM 转换:支持范围需核对版本。
追问
- 答:lambda 引用可保存为函数类型变量吗?答:可以,保存后可反注册或传递。
- 答:SAM 转换生成对象有开销吗?答:按运行时机制生成接口实例,高频路径可实测。
04.8.1.4-061 Kotlin 函数类型与 Java Function/Consumer 如何映射?
一句话结论
互操作时 Kotlin 函数类型按签名映射为对应 Java 函数式接口或函数引用类;(T) -> Unit 对应消费型接口,(T) -> R 对应转换型接口。
概念解释
Java 8 函数式接口如 Function、Consumer、Supplier 与 Kotlin 函数类型参数/返回方向对应。具体映射类名由编译器与目标接口决定,框架 API 按其签名适配。
原理流程
- 检查函数类型参数与返回方向。
- 消费型对应 Consumer 一类接口。
- 转换型对应 Function 一类接口。
- 无参无返回对应 Runnable 一类。
代码或图示
val printer: (String) -> Unit = { println(it) }
// Java 侧适配为消费字符串的函数式接口实现
常见误区
- 假设所有 Java 函数式接口都有固定 Kotlin 映射名:以框架签名为准。
- 忽略函数类型可空性:接口参数空性按映射注解呈现。
追问
- 答:函数类型型变方向?答:参数逆变、返回协变,与函数式接口一致。
- 答:跨语言传递函数引用注意什么?答:捕获变量生命周期与接口实现实例持有。
04.8.1.4-062 Java 侧如何访问 Kotlin 属性的 getter/setter?
一句话结论
Kotlin 属性在 Java 侧按 getter/setter 命名约定访问:val 生成 getter,var 生成 getter 与 setter;@JvmField 时直接访问字段。
概念解释
属性名映射为 Java Bean 风格访问器:name → getName()/setName()。布尔属性 getter 命名按规则生成。框架按访问器约定识别属性。
原理流程
val属性生成 getter。var属性生成 getter + setter。- 方法名按属性名前缀规则拼接。
- 标注
@JvmField改为字段访问。
代码或图示
class Person {
val name: String = "Ann"
var age: Int = 30
}
// Java: person.getName(); person.setAge(31)
常见误区
- 以为 Java 直接访问 Kotlin 字段:默认走访问器。
- 属性命名与 getter 前缀冲突:生成方法名不符合 Java 习惯。
追问
- 答:布尔 getter 怎么命名?答:按
is/get规则,具体以编译器生成为准。 - 答:自定义访问器在 Java 侧如何呈现?答:按自定义 getter/setter 方法访问。
04.8.1.4-063 const val 在 Java 侧如何内联?
一句话结论
const val 编译期常量在 Java 调用点内联为字面量,不读取 Kotlin 类字段;基本类型与字符串适用,值在编译期确定。
概念解释
常量内联意味着 Kotlin 侧后续修改常量值,已编译 Java 调用方不会自动更新。const val 必须位于顶层或伴生对象,初始值为编译期表达式。
原理流程
- 常量初始值编译期可求值。
- 引用处替换为字面量。
- Java 调用点不访问字段。
- 修改常量需重新编译调用方。
代码或图示
const val MAX_RETRY = 3
// Java 编译后引用字面量 3,而非读取常量字段
常见误区
- 以为改常量 Java 运行时自动生效:内联值需重编译。
- 在
const val上放运行时配置值:不符合编译期常量约束。
追问
- 答:
const val与@JvmField区别?答:前者编译期内联;后者暴露运行时字段。 - 答:常量能是可空类型吗?答:const 限基本类型与 String,按规则约束。
04.8.1.4-064 可变属性暴露给 Java 有哪些线程安全提醒?
一句话结论
Kotlin var 属性在 Java 侧生成可读写访问器,可变状态跨语言共享时需要同步、volatile 或并发容器保护;属性本身不提供天然线程安全。
概念解释
可写属性被多线程访问时存在可见性与竞争问题。Java 框架直接调用 setter 修改状态,Kotlin 侧与 Java 侧共享同一可变状态,需在设计层保护。
原理流程
var属性生成 getter/setter。- 多线程并发读写同一属性。
- 无同步时可见性与竞争不确定。
- 按需使用同步方法、
@Volatile或并发集合。
代码或图示
class Counter {
var count: Int = 0 // 跨线程访问需同步保护
}
常见误区
- 以为 Kotlin 属性自动线程安全:关键字不提供同步。
- 可变公开属性被框架并发改写:封装边界缺失。
追问
- 答:
@Volatile作用是什么?答:保证变量读写可见性,不保证复合操作原子性。 - 答:推荐的可变状态封装?答:私有可变字段 + 受控方法,方法内同步或用并发结构。
04.8.1.4-065 Java 如何调用 Kotlin 扩展函数?
一句话结论
扩展函数编译为静态工具方法,首参为接收者;Java 不能在实例上点号调用扩展,需按生成的工具类静态方法传入接收者。
概念解释
扩展不写入原类方法表,Java 反射与实例方法列表看不到。顶层扩展归属文件包装类,成员扩展归属对应类/伴生对象,调用签名按编译产物确定。
原理流程
- 扩展编译为静态函数,接收者为首参。
- Java 按包装类静态方法调用。
- 传入接收者实例与其余参数。
- 调用方不能按 Kotlin 点号语法访问。
代码或图示
fun String.shout() = this.uppercase()
// Java: 工具类.shout(str),而非 str.shout()
常见误区
- Java 侧期待实例方法调用扩展:找不到方法。
- 文档把扩展写成类型成员:误导跨语言调用。
追问
- 答:如何向 Java 暴露便捷方法?答:改为类成员方法、伴生静态方法或顶层函数,配合注解命名。
- 答:扩展属性 Java 侧可见吗?答:编译为静态访问器方法,同样按工具类调用。
04.8.1.4-066 泛型通配符在互操作签名上如何表现?
一句话结论
Kotlin 型变导出为 Java 通配符:out 对应 ? extends,in 对应 ? super;无界投影对应 ?。框架读取签名时按通配符解析泛型边界。
概念解释
两侧型变方向一致,声明位置不同。导出签名决定 Java 泛型 API 兼容性;通配符过多可能影响框架反序列化与类型推断,必要时用注解抑制。
原理流程
- 编译器按 Kotlin 型变生成 Java 泛型签名。
- 协变位置导出
? extends T。 - 逆变位置导出
? super T。 - 框架按通配符限制读写位置。
代码或图示
interface Reader<out T> { fun read(): T }
// Java 侧签名近似: Reader<? extends T>
常见误区
- 忽略导出通配符导致框架泛型解析失败。
- 型变标注与框架签名要求冲突:需注解调整。
追问
- 答:如何抑制导出通配符?答:
@JvmSuppressWildcards,按位置标注。 - 答:通配符在 Kotlin 读取 Java 签名时如何呈现?答:映射为 out/in 投影或星投影。
04.8.1.4-067 数组互操作:IntArray 与 Array<Int> 如何区分?
一句话结论
IntArray 映射 JVM 原始 int[],元素无装箱;Array<Int> 是引用数组,元素为 Integer 包装对象。互操作方法签名与内存布局不同。
概念解释
专用原始数组对应 Java 原始类型数组;泛型数组对应对象数组。Kotlin 方法签名在 Java 侧呈现对应数组类型,转换需专用方法。
原理流程
- 专用数组工厂生成原始类型数组。
- 泛型数组生成引用数组。
- 跨语言调用按签名类型传递。
- 互转通过
toIntArray()/toTypedArray()。
代码或图示
val prim: IntArray = intArrayOf(1, 2)
val boxed: Array<Int> = arrayOf(1, 2)
常见误区
- 把
Array<Int>当原始数组:元素装箱。 - Java 方法期望
int[]却传Array<Int>:签名不匹配。
追问
- 答:其他原始类型同理吗?答:
LongArray/DoubleArray/BooleanArray/CharArray等对应原始数组。 - 答:数组元素可空吗?答:专用原始数组不可空;泛型数组元素类型可标注可空。
04.8.1.4-068 字符串与基本类型在跨语言边界的装箱表现是什么?
一句话结论
字符串两侧均为 java.lang.String 引用;基本类型按原始/包装位置装箱,可空与泛型边界产生包装对象,跨边界注意拆箱空值风险。
概念解释
字符串无原始类型映射,直接共享 JVM 字符串对象。数字、布尔在原始位置与包装位置间转换,空包装对象拆箱可能触发 NPE。
原理流程
- 字符串两侧类型一致。
- 非空基本类型传原始值。
- 可空/泛型位置装箱为包装类。
- 包装为空时拆箱解引用抛 NPE。
代码或图示
fun merge(a: String, b: Int?): String = "$a-${b ?: 0}"
常见误区
- 把可空包装对象直接拆箱:空值 NPE。
- 跨语言忽略字符集:字符串编码在 IO 边界处理。
追问
- 答:字符串跨语言共享 intern 实例吗?答:按 JVM 字符串池与创建规则,内容比较用
==。 - 答:装箱性能敏感场景怎么做?答:减少可空数字变量与泛型容器包装,使用专用原始数组。
04.8.1.4-069 场景:处理 Java SDK 返回的 List! 应写怎样的防御代码?
一句话结论
在适配层把平台集合声明为可空,先判容器再判元素,安全调用与校验后暴露确定类型给业务层;补充空集合、null 元素与 SDK 异常用例。
概念解释
防御写法集中在边界门面:不把平台类型透传业务层。容器可能为空引用,元素可能为 null,两层分别处理,关键结果用校验函数提升非空。
原理流程
- 调用 SDK 方法,结果赋给
List<T>?。 - 容器判空后遍历,元素判空或过滤。
- 契约必填结果用 requireNotNull 校验。
- 业务层只接触确定可空/非空类型。
代码或图示
class SdkAdapter(private val sdk: ThirdPartySdk) {
fun items(): List<Item> =
sdk.findItems()
.orEmpty()
.filterNotNull()
.map { Item(it.id, it.name ?: "unknown") }
}
常见误区
- 业务代码各处直接调 SDK 并随手断言。
- 只判容器空,忽略元素为 null。
追问
- 答:orEmpty 处理哪一层?答:容器可空兜底为空列表,元素空性仍需单独处理。
- 答:测试覆盖哪些路径?答:返回 null、空列表、元素为 null、SDK 抛异常四类。
04.8.1.4-070 场景:Kotlin 集合暴露给 Spring/Java 框架如何选型?
一句话结论
按框架要求选择只读 List/Set/Map 或可变集合;对外 API 优先暴露只读视图,需要框架写入时用可变集合,注意泛型通配符与空性注解兼容。
概念解释
Spring 数据绑定、序列化、ORM 常依赖 Java Bean 访问器与集合类型。暴露只读集合减少误改;框架需要填充集合时返回可变实例。泛型签名按框架反序列化要求核对。
原理流程
- 确认框架读取还是写入集合。
- 只读场景暴露 List/Set/Map 视图。
- 写入场景提供 MutableCollection 实例。
- 核对泛型通配符、可空性与注解兼容。
代码或图示
data class ApiResponse(
val items: List<Item> = emptyList()
)
常见误区
- 暴露内部可变集合引用给框架:外部可改内部状态。
- 忽略框架泛型反序列化要求:类型解析失败。
追问
- 答:框架需要无参构造怎么办?答:data class 默认值与构造配置按框架要求评估,必要时补注解。
- 答:集合空性文档怎么写?答:明确集合是否可能为 null、元素是否可空,与签名一致。
04.8.1.4-071 场景:大日志或数据流如何选择 Sequence 还是集合?
一句话结论
数据量大、来源流式、链路长时用 Sequence 逐元素流过;结果需要多次复用、随机访问或数据量小、链路短时用普通集合。
概念解释
日志文件、消息流、大查询结果适合惰性处理,避免中间集合撑爆内存;缓存后反复计算的结果固化为 List。选型结合末端结果大小与遍历次数。
原理流程
- 评估数据规模、是否有限、遍历次数。
- 大/无限 + 单遍链式处理:Sequence。
- 结果复用或下标访问:toList 固化。
- 小数据短链:直接集合链更直观。
代码或图示
val stats = logLines.asSequence()
.filter { it.contains("ERROR") }
.map { parse(it) }
.take(100)
.toList()
常见误区
- 无限流调用无界末端操作:无法终止。
- 大结果固化后又多次遍历:内存占用不变,先评估是否需要全量收集。
追问
- 答:Sequence 与 Java Stream 定位相似吗?答:都是惰性链式处理,API 与运行机制不同,详见对比题。
- 答:数据库流式结果如何接入?答:按驱动迭代器包装序列或直接逐行消费。
04.8.1.4-072 场景:对象初始化用 apply 还是构造器默认值?
一句话结论
必填与有合理默认值的属性放构造参数默认值;可选回调、状态装配、跨多成员配置用 apply;构造器保证基本不变量,apply 做补充装配。
概念解释
构造参数在创建时确定,便于测试与不可变建模;apply 在实例创建后配置,适合框架注入、监听器注册。简单默认值优先构造器,避免无意义作用域嵌套。
原理流程
- 识别属性是否必填、有无默认值。
- 基本属性进构造参数。
- 可选装配逻辑进 apply 块。
- 返回配置完成的实例。
代码或图示
class Button(val label: String, var enabled: Boolean = true)
val btn = Button("Submit").apply {
enabled = false
onClick = { submit() }
}
常见误区
- 构造器默认能解决的属性塞进 apply:样板嵌套。
- apply 内做必填校验:应在构造期或工厂方法保证。
追问
- 答:构造注入与字段注入场景?答:依赖对象用构造器;框架回调装配用 apply 配合 lateinit。
- 答:apply 适合返回新对象吗?答:apply 返回原实例,不可变更新应走 copy 或构造新实例。
04.8.1.4-073 场景:链式变换中插入日志用 also 怎么做?
一句话结论
在链式步骤之间插入 also { log.debug(...) },返回原对象不改变主链类型;日志/校验/注册等副作用穿插在数据流中,不参与值变换。
概念解释
also 接收 it 引用当前对象,块内读取状态打印或校验。主链下一步仍操作同一对象;需要变换值用 map/let,不要在 also 内改值期待带出。
原理流程
- 主链得到当前对象。
- also 传入对象为
it。 - 块内执行日志/校验副作用。
- 返回原对象继续主链。
代码或图示
val order = buildOrder(cart)
.also { log.info("order created: ${it.id}") }
.also { validateStock(it) }
.apply { status = Status.PENDING }
常见误区
- also 内修改主值却期待链式下一步看到:返回的是原对象引用。
- 日志逻辑过重混入 also:复杂副作用应拆为独立方法。
追问
- 答:日志插在变换前还是变换后?答:按需要观察的阶段选择;also 不改变对象,位置不影响值。
- 答:also 与 let 穿插日志区别?答:also 返回对象本身,let 返回变换结果。
04.8.1.4-074 场景:DTO 转换用 let 还是 map 扩展?
一句话结论
单个对象的可空变换用 ?.let;集合逐元素映射用 map 扩展。按作用对象数量选择,不要在集合上嵌套多层 let 做元素转换。
概念解释
let 作用于单个接收者,适合可空 DTO 到领域模型的安全映射;map 遍历集合逐元素转换并返回新集合。职责清晰后链式结构更易读。
原理流程
- 判断输入是单个对象还是集合。
- 单个可空对象:let 内映射字段。
- 集合元素:map 逐元素转换。
- 空值分支按
?:或返回 null 处理。
代码或图示
// 单个
val profile: Profile? = dto?.let { Profile(it.name, it.age) }
// 集合
val users = dtos.map { User(it.id, it.name) }
常见误区
- 集合元素转换写成
list.map { it.let { ... } }:多余嵌套。 - let 内做批量集合操作:职责错位。
追问
- 答:转换可能失败返回 null 怎么处理?答:let 内返回 null 结果类型可空,外层
?:兜底。 - 答:扁平一对多转换用什么?答:flatMap,元素映射为集合后合并。
04.8.1.4-075 性能:集合即时链的中间对象分配有什么成本?
一句话结论
普通集合链每个中间操作生成新集合,元素在步骤间重复复制;链路越长、数据量越大,中间集合的堆分配与复制成本越高。
概念解释
filter 产出中间 List,map 再产出新 List,旧中间集合等待回收。热点大集合链上,分配压力、GC 暂停与复制耗时累积;优化方向是减少步骤或改用惰性序列。
原理流程
- 每步遍历输入集合。
- 分配新集合容纳结果。
- 元素复制到新集合。
- 旧中间集合成为垃圾待回收。
代码或图示
// 两步操作产生两个中间 List
list.filter { it > 1 }.map { it * 2 }
常见误区
- 只看最终结果大小,忽略中间集合数量。
- 小数据链也追求惰性:调度开销可能不划算。
追问
- 答:如何测量中间分配?答:对比链步骤数、对象分配热点与 GC 次数,大样本实测。
- 答:减少中间集合的手段?答:合并相邻操作、改用 Sequence、末端按需取值。
04.8.1.4-076 性能:Sequence 为何在末端执行时不产生中间集合?
一句话结论
Sequence 中间操作只记录步骤,末端迭代时逐元素流过整条链,过程中只持有当前元素,不落地每步结果集合,因此消除中间集合副本。
概念解释
惰性模型把收集推迟到末端:每个元素先过 filter 再过 map,到达末端才被收集。内存占用从「中间集合数量 × 元素」降为当前元素加末端结果。
原理流程
- 中间操作装饰序列,不分配集合。
- 末端迭代请求元素。
- 单元素依次穿过步骤链。
- 末端结果收集为最终集合。
代码或图示
val r = source.asSequence()
.filter { it > 1 }
.map { it * 2 }
.toList() // 仅此处落地最终 List
常见误区
- 以为 Sequence 完全无内存:末端结果集合仍占内存。
- 每步 toList 再 asSequence:中间分配回流。
追问
- 答:Sequence 调度开销来自哪里?答:迭代器与步骤函数调用,小数据下可能超过节省的分配。
- 答:无限序列内存如何控制?答:take/first 等有界末端,不收集全量。
04.8.1.4-077 性能:作用域函数有运行时开销吗?
一句话结论
作用域函数本质是标准库函数调用,开销接近普通函数转发;不创建额外包装对象,热点路径上成本通常可忽略,复杂 lambda 体的成本才是主体。
概念解释
let/run/apply/also/with 是高阶函数,调用产生一次函数转发与 lambda 执行。与手写临时变量相比,差异主要是语法封装,性能敏感场景可实测对比。
原理流程
- 调用作用域函数传入接收者与 lambda。
- 函数绑定接收者并执行 lambda。
- 返回 lambda 结果或接收者。
- 无独立包装对象分配。
代码或图示
val x = value.also { log(it) }
// 等价:临时变量 + 语句 + 返回变量的手写结构
常见误区
- 以为作用域函数有显著对象分配:通常只是函数调用。
- 在超高频循环里嵌套多层作用域:lambda 体与转发次数累积。
追问
- 答:with 与扩展形式性能有别吗?答:实现方式略有差异,热点路径实测即可。
- 答:可读性与性能如何平衡?答:非热路径优先可读性,热路径手写局部变量对比实测。
04.8.1.4-078 ArrayList 与 LinkedList 如何选型?
一句话结论
随机下标访问、遍历为主选 ArrayList(连续存储);频繁首尾插入删除、节点频繁增删选 LinkedList;Kotlin 业务集合默认优先 ArrayList 实现。
概念解释
ArrayList 数组连续存储,下标访问 O(1),中间插入移动元素;LinkedList 节点串联,首尾增删快,随机访问需遍历。业务多数场景读多写少,ArrayList 更合适。
原理流程
- 分析访问模式:随机访问/遍历 vs 首尾增删。
- 连续存储选 ArrayList。
- 节点式增删选 LinkedList。
- 按元素规模与操作频率实测。
代码或图示
val array = mutableListOf(1, 2, 3) // 近似 ArrayList 实现
// 需要 LinkedList 时按标准库/Java 实现类型创建
常见误区
- 以为 LinkedList 所有操作都更快:随机访问劣势明显。
- 频繁中间插入用数组实现:元素移动成本高。
追问
- 答:Kotlin mutableListOf 返回哪种实现?答:以标准库版本为准,业务代码面向 List 接口编程。
- 答:队列/栈结构用什么?答:按标准库双端队列实现或专用集合,具体类型以版本为准。
04.8.1.4-079 坑:只读接口引用可变实现被外部改写怎么办?
一句话结论
只读引用不复制底层数据,持有同一可变实例的其他引用或内部方法仍可修改;需要防外部误改时封装内部可变状态,对外暴露只读视图或返回复制快照。
概念解释
典型泄漏:类把内部 MutableList 直接作为只读 List 返回。外部虽不能经接口改,但引用共享,后续内部修改外部可见,其他持引用方也可强转改写。
原理流程
- 内部持有可变集合。
- 方法返回内部集合只读引用。
- 底层被内部或其他引用修改。
- 只读引用观察到变化。
代码或图示
class Cart {
private val items = mutableListOf<String>()
// 风险:返回内部引用
fun unsafe(): List<String> = items
// 稳妥:返回复制快照
fun snapshot(): List<String> = items.toList()
}
常见误区
- 把只读返回值写进不可变契约文档。
- 跨线程发布内部可变集合引用。
追问
- 答:视图与复制如何取舍?答:视图省拷贝但共享状态;复制隔离但有开销,按并发与修改场景选。
- 答:data class 集合属性注意什么?答:可变集合属性参与相等性,修改后集合契约失配。
04.8.1.4-080 坑:Sequence 多次遍历会怎样?
一句话结论
部分序列遍历一次后迭代器耗尽,第二次末端迭代无元素或按来源重新生成;需要复用结果应先 toList() 固化,不要把同一 Sequence 传入多个末端操作。
概念解释
与 List 可反复遍历不同,序列基于迭代器消费。来源不同行为可能有差异,稳妥做法是收集为集合后多次操作,避免第二次遍历结果不确定。
原理流程
- 首次末端遍历消费迭代器。
- 迭代器到达末尾不可重置。
- 第二次遍历无元素或重新生成。
- 复用场景先转 List。
代码或图示
val seq = source.asSequence()
val first = seq.toList()
// 再次使用同一 seq 行为不确定;复用应:
val reused = source.asSequence().toList()
常见误区
- 假设 Sequence 可像 List 反复遍历。
- 同一序列传给两个末端函数:状态耗尽。
追问
- 答:哪些序列可重复遍历?答:基于可重复集合的视图行为不同,具体以标准库实现为准(待确认)。
- 答:如何确认序列一次性?答:查看标准库序列类型文档或实测两次末端结果。
04.8.1.4-081 坑:作用域函数误用返回值有哪些表现?
一句话结论
apply/also 返回对象本身,let/run/with 返回 lambda 结果;误用后链式下一步类型错误、取到对象而非计算值,或返回旧对象忽略变换。
概念解释
典型错误:apply 后期望拿到 lambda 计算结果;also 内修改值却以为带出;let 后继续访问对象成员。阅读链式代码先标注每步返回类型。
原理流程
- 确认函数返回接收者还是 lambda 结果。
- 按返回类型匹配下一步方法。
- 类型不匹配即选型错误。
- 重构:配置用 apply,变换用 let/run,副作用穿插用 also。
代码或图示
// 错误期待:apply 返回长度
// val len = user.apply { name.length } // len 仍是 User
val len = user.run { name.length } // 返回 String 长度
常见误区
- 凭函数名记忆选型,不核对返回值。
- 链式中混用返回对象与返回结果的函数。
追问
- 答:返回 Unit 的 lambda 影响什么?答:链类型变 Unit,后续不能访问原对象成员。
- 答:如何快速判断?答:看函数名分组:apply/also 返回自身,let/run/with 返回结果。
04.8.1.4-082 坑:Java 平台类型在 Kotlin 侧解引用 NPE 如何排查?
一句话结论
崩溃定位到 Kotlin 调用点后,回溯值来源到 Java/三方边界,确认方法是否可能返回 null;修复是在适配层收口空性并补空值测试,而不是在崩溃行加 !!。
概念解释
平台类型空性未知,假定非空后解引用触发 NPE。排查链:崩溃行 → 变量来源 → Java 方法签名与实现 → 空性注解 → 复现用例。
原理流程
- 读堆栈定位 Kotlin 解引用行。
- 沿赋值链回溯跨语言调用点。
- 检查注解与实现是否可能为空。
- 适配层声明可空、安全调用/校验,补测试。
代码或图示
// 崩溃:val len = javaObj.name.length
// 回溯:name 来自未标注 Java 方法
// 修复:val name: String? = javaObj.name; name?.length ?: 0
常见误区
- 崩溃行直接断言非空:空值来源未解决。
- 只在 Kotlin 代码内找空值:源头在 Java 边界。
追问
- 答:日志应补什么上下文?答:调用参数、对象标识、被调方法名,便于复现空值路径。
- 答:哪些 Java 返回最需防御?答:集合、字符串、包装类型与历史未标注 SDK 方法。
04.8.1.4-083 坑:@JvmOverloads 与既有 Java 方法签名冲突怎么办?
一句话结论
生成的重载若与 Java 父类/接口既有方法签名重复,编译报重复方法;需调整参数默认值、方法名或用 @JvmName 区分,不能靠忽略诊断解决。
概念解释
@JvmOverloads 按参数数量生成转发方法,与既有签名冲突时 JVM 签名重复。冲突可能来自父类方法、同类重载或第三方接口,需核对生成签名。
原理流程
- 标注注解后编译器生成递减重载。
- 与既有方法签名比对。
- 重复签名编译报错。
- 调整参数、方法名或移除注解。
代码或图示
@JvmOverloads
fun greet(name: String, prefix: String = "Hi")
// 若 Java 侧已有 greet(String),签名冲突需处理
常见误区
- 以为注解只影响 Kotlin 调用方:它改变 Java 可见签名。
- 与父类方法重载不兼容时强行保留注解。
追问
- 答:如何查看生成签名?答:反编译产物或 javap 一类工具核对方法描述符。
- 答:默认参数不在尾部影响重载吗?答:省略规则受限,具体生成以编译器为准。
04.8.1.4-084 坑:Map.get 与 [] 返回可空引发链式问题怎么处理?
一句话结论
Map 取值缺失返回 null,链式直接解引用会触发空安全报错或 NPE;按语义用 ?: 兜底、getOrElse 计算缺省,或先 containsKey 区分「无键」与「值为 null」。
概念解释
[]/get 返回可空值。需要区分键不存在与值显式为 null 时,用 containsKey 判断;普通缺省场景用 getOrElse/getOrDefault。
原理流程
- 按键查找条目。
- 无键或值为 null 都可能得到 null。
- 安全调用/兜底后再使用。
- 需要区分两种空态时检查 containsKey。
代码或图示
val cap: Map<String, Int> = mapOf("a" to 1)
val v = cap["b"] ?: 0
val fallback = cap.getOrElse("x") { -1 }
常见误区
- 把 Map 取值当非空直接链式调用成员。
- 无法区分无键与空值却用同一兜底逻辑。
追问
- 答:
getOrElse与?:区别?答:前者 lambda 计算缺省值,后者是通用空合并。 - 答:可变 Map 按键写入用什么?答:
map[key] = value或put。
04.8.1.4-085 坑:filterIsInstance 后的泛型擦除边界是什么?
一句话结论
filterIsInstance 只能判断外层类型,擦除后无法区分 List<String> 与 List<Int>;嵌套容器元素实参判断需显式类型令牌或逐层检查。
概念解释
运行时类对象不携带泛型实参。reified 版本在编译期保留外层类型,元素实参仍擦除;把过滤结果强转为嵌套泛型容器属于未检查强转。
原理流程
- 遍历元素做外层类型归属判断。
- 匹配元素强转为目标类型。
- 嵌套泛型实参运行时不可得。
- 需要元素类型判断时逐项检查或保存令牌。
代码或图示
val mixed: List<Any> = listOf(listOf("a"), listOf(1))
// 无法用 filterIsInstance 区分 List<String> 与 List<Int>
常见误区
- 期待 filterIsInstance 恢复嵌套泛型实参。
- 未检查强转后不做运行时校验。
追问
- 答:如何保存嵌套类型信息?答:数据结构显式持有类型令牌,或序列化库用泛型类型描述。
- 答:reified 版本突破擦除了吗?答:只保留外层 reified 类型,不恢复容器元素实参。
04.8.1.4-086 与 Java 8+ 对比:Stream、Sequence 与 Iterable 链有何异同?
一句话结论
三者都是链式数据处理:Iterable 即时逐集合处理,Stream 与 Sequence 惰性末端触发;Stream 绑定 JVM 并行能力,Sequence 是 Kotlin 标准库惰性序列,API 风格不同。
概念解释
普通 Iterable 链每步生成中间集合;Stream/Sequence 中间操作记录步骤,末端触发求值。Stream 支持并行分支,Sequence 聚焦单线程惰性迭代;迁移时映射 map/filter/collect 概念。
原理流程
- Iterable:即时生成中间集合。
- Stream:惰性流水线,末端操作收集,可并行。
- Sequence:惰性逐元素流过,末端收集。
- 结果语义等价,机制与 API 不同。
代码或图示
// Kotlin Sequence 对应 Java Stream 流水线概念
source.asSequence().filter { it > 0 }.map { it * 2 }.toList()
常见误区
- 把 Sequence 当作 Kotlin 版 Stream 直接套用并行 API:Sequence 无并行分支。
- 以为 Stream 终端操作等价 Sequence 全部末端操作:概念相近,方法名不同。
追问
- 答:Stream 中间操作有状态与无状态区分吗?答:有,Sequence 操作同样分依赖历史元素与纯映射类型。
- 答:迁移注意什么?答:可空性、类型推断与惰性边界,并行需求在 JVM 侧另行评估。
04.8.1.4-087 与 Java 对比:集合不可变性策略有何差异?
一句话结论
JDK/Guava 提供实现层不可变集合(修改抛异常);Kotlin 只读接口是类型层视图约束,底层实现可能仍可变,需要冻结语义时复制快照或使用标准库不可变实现。
概念解释
不可变策略分两层:接口限制调用方写法,实现层拒绝修改。Kotlin 只读 List 属于前者;JDK List.of、Guava ImmutableList 属于后者。工程文档需说明不可变保证层级。
原理流程
- Kotlin 只读引用:调用方无写入方法。
- 底层实例可能被可变引用修改。
- 实现层不可变:任何修改入口抛异常。
- 跨语言共享集合按实际实现判断安全性。
代码或图示
val readOnly: List<String> = listOf("a")
// 是否实现层不可变取决于标准库实现版本;对外契约需核实
常见误区
- 把 Kotlin 只读接口等同于 JDK 不可变集合。
- 跨线程共享只读视图却不确认底层实现。
追问
- 答:Kotlin 标准库不可变实现状态?答:以官方文档与版本实测为准(待确认)。
- 答:稳妥的不可变传递方式?答:返回复制快照,或封装内部状态只暴露只读视图。
04.8.1.4-088 与 Java 对比:try-with-resources 与 use 扩展有何对应?
一句话结论
Java try-with-resources 自动关闭实现 AutoCloseable 的资源;Kotlin use 扩展在 lambda 结束后关闭资源,异常路径同样保证关闭,语义对应。
概念解释
use 是标准库扩展,接收可关闭资源,执行 lambda 后调用 close;异常被传递,关闭异常按标准库规则处理。资源无需在 finally 手写关闭。
原理流程
- 获取可关闭资源实例。
- 调用
use { }传入处理逻辑。 - lambda 正常或异常结束后关闭资源。
- 原始异常继续传播。
代码或图示
java.io.File("data.txt").bufferedReader().use { reader ->
reader.lineSequence().forEach { println(it) }
}
常见误区
- 资源未实现 AutoCloseable 就用 use:类型不匹配。
- use 块内手动关闭:重复关闭或遗漏异常路径。
追问
- 答:use 关闭异常与业务异常如何处理?答:按标准库实现规则,具体行为以版本文档为准。
- 答:多资源依次关闭怎么写?答:嵌套 use 或按标准库多资源工具,避免手写 finally。
04.8.1.4-089 Kotlin 2.x 集合与标准库有哪些需要确认的现状?
一句话结论
集合接口、Sequence、作用域函数是稳定核心;具体工厂实现类型、新集合 API、不可变实现保证与部分互操作注解随版本演进,需在项目编译版本实测确认。
概念解释
基线 Kotlin 2.x、JDK 17+。回答版本问题区分稳定特性与演进 API;不确定的实现类名、默认行为、框架兼容标注「待确认」并写验证步骤。
原理流程
- 记录编译器与标准库版本。
- 查官方文档集合与互操作章节。
- 最小工程编译验证签名、实现类型与行为。
- 无法核实处不编造版本号与类名。
代码或图示
// 待确认:目标版本集合实现类、不可变保证与新增 API
// 验证点:编译产物类型、末端操作行为、Java 签名映射
常见误区
- 把旧文档实现类名写成 2.x 固定行为。
- 混淆标准库版本与编译器版本。
追问
- 答:官方文档入口?答:kotlinlang.org collections、sequences、scope-functions、java-interop 章节。
- 答:待确认答案格式?答:不确定点 + 验证命令/工程步骤 + 预期观察结果。
04.8.1.4-090 面试手写:把一段 Java Stream 改写为 Kotlin 集合链
一句话结论
按概念映射:filter→filter、map→map、collect(toList())→toList();可空性与类型推断在 Kotlin 侧补充,惰性链路按需 asSequence()。
概念解释
评分点:操作顺序保持、末端收集、类型推断、可空处理。Stream 并行需求在 Kotlin Sequence 无对应,需说明在 JVM 侧另行处理。
原理流程
- 识别 Stream 中间操作与末端收集。
- 逐映射为 Kotlin 集合/Sequence 操作。
- 末端 toList/toSet 固化结果。
- 补可空元素过滤与类型收窄。
代码或图示
// Java
list.stream().filter(x -> x > 1).map(x -> x * 2).collect(Collectors.toList());
// Kotlin
list.filter { it > 1 }.map { it * 2 }.toList()
常见误区
- 末端忘记收集:Sequence 步骤不执行。
- 忽略 Java 装箱类型在 Kotlin 侧的可空映射。
追问
- 答:Stream
flatMap对应什么?答:KotlinflatMap。 - 答:Stream
reduce对应?答:Kotlinreduce/fold,初始值策略按语义选择。
04.8.1.4-091 面试手写:为对象选择合适作用域函数并说明理由
一句话结论
按「返回对象本身还是结果 + this 还是 it」选型:配置初始化 apply,副作用穿插 also,非空变换 let,对象上计算 run,集中调用一组成员 with。
概念解释
答题先给场景,再写函数选择与代码,说明返回值类型与引用方式。能解释为什么不用其他函数,比背函数名更重要。
原理流程
- 判断是否需要返回对象继续传递。
- 判断内部引用 this 还是 it。
- 按决策表确定函数。
- 说明空安全组合(
?.let)。
代码或图示
// 配置:apply 返回对象
val view = View().apply { title = "Detail" }
// 非空变换:let 返回结果
val name = user?.let { it.name.trim() }
常见误区
- 选型只凭习惯,不解释返回值与引用方式。
- 把配置场景写成 run/let,链类型出错。
追问
- 答:with 适用什么场景?答:已有非空对象集中调用一组成员,不支持链式安全调用。
- 答:also 与 apply 如何区分?答:also 用 it 做副作用穿插,apply 用 this 做属性配置。
04.8.1.4-092 面试手写:解释一段集合链的执行次数
一句话结论
普通集合链按步骤逐集合遍历:filter 遍历一次产生中间集合,map 再遍历一次;Sequence 末端逐元素穿过链,元素按步骤数被处理,末端才收集。
概念解释
评分点:区分即时与惰性模型,数清每步遍历次数与中间集合。元素总量 × 步骤数是处理量级;Sequence 中间不落地集合。
原理流程
- 判定链是 Iterable 即时还是 Sequence 惰性。
- 即时:每步遍历当前集合生成新集合。
- 惰性:末端迭代,单元素穿过全部步骤。
- 统计中间集合数量与元素处理次数。
代码或图示
val r = listOf(1, 2, 3)
.filter { it > 1 } // 遍历 3 个,产出 2 个
.map { it * 2 } // 遍历 2 个,产出 2 个
常见误区
- 把 Sequence 当成逐步生成中间集合。
- 忽略末端操作才触发惰性计算。
追问
- 答:
take限制遍历多少?答:取指定数量元素即停止,后续步骤不再处理。 - 答:如何实测执行次数?答:在操作中计数打印或查看分配热点。
04.8.1.4-093 面试手写:补全 Java 互操作注解
一句话结论
按目标补注解:默认参数重载 @JvmOverloads,静态成员 @JvmStatic,字段暴露 @JvmField,命名调整 @JvmName,通配符控制 @JvmSuppressWildcards。
概念解释
答题先判断 Java 调用方需要什么签名形态,再选注解。注解作用位置(文件/函数/参数)与类型需对应,混淆位置不生效。
原理流程
- 分析 Java 侧调用方式与签名要求。
- 默认值重载 → JvmOverloads。
- 静态调用 → JvmStatic;字段访问 → JvmField。
- 泛型签名 → 通配符注解;命名 → JvmName。
代码或图示
class Api {
companion object {
@JvmStatic
@JvmOverloads
fun ping(timeout: Int = 1000): String = "pong"
}
}
常见误区
- 注解作用域写错:文件级/函数级/参数级不可混用。
- 把 JvmField 加在需要访问器逻辑的属性上。
追问
- 答:JvmStatic 作用于哪些声明?答:伴生对象成员与对象声明成员,具体以文档为准。
- 答:注解后如何验证?答:反编译查看 Java 可见方法签名与描述符。
04.8.1.4-094 集合排序实战:多条件排序与空值置后怎么写?
一句话结论
用 compareBy 链式多条件,nullsLast/nullsFirst 包装比较器控制空值位置;排序返回新列表,原集合不变。
概念解释
先按主键再按次键排序,可空元素用 nulls 包装器定位。数字/字符串自然顺序作为比较器基础,复杂规则自定义 comparator。
原理流程
- 构造多键 compareBy 链。
- 可空键用 nullsLast/nullsFirst 包装。
- sortedBy/sortedWith 应用比较器。
- 返回排序后新集合。
代码或图示
data class Item(val name: String?, val price: Int)
val sorted = items.sortedWith(
compareBy(nullsLast<String>()) { it.name }
.thenBy { it.price }
)
常见误区
- 可空键直接比较:空值顺序依赖默认规则。
- 多条件顺序写反:主次排序键错位。
追问
- 答:原地排序用什么?答:可变集合
sort()/sortBy,修改原集合。 - 答:自定义反向顺序?答:
reversed()或比较器反向规则。
04.8.1.4-095 Map 合并与累加:toMap/associateWith 如何使用?
一句话结论
associateWith 由元素生成键值对构建 Map,toMap 收集 Pair 序列;按键合并累加用 groupBy 后聚合,或 toMap 冲突时按合并规则处理。
概念解释
从集合构建 Map:元素为键用 associateWith,元素为值用 associate;Pair 序列用 toMap。重复键冲突默认覆盖,需要累加时先分组再聚合。
原理流程
- 遍历源集合元素。
- 选择键值映射方式生成 Pair。
- toMap/associateWith 构建 Map。
- 冲突按键规则覆盖或分组聚合。
代码或图示
val lengths = listOf("a", "bb").associateWith { it.length }
val pairs = listOf("x" to 1, "y" to 2)
val map = pairs.toMap()
val counts = words.groupingBy { it }.eachCount()
常见误区
- 重复键期待全部保留:Map 键唯一。
- 累加场景直接 toMap:值被覆盖而非求和。
追问
- 答:
associate与associateWith区别?答:associate 同时映射键值;associateWith 元素为键、值由选择器生成。 - 答:Map 值累加用什么?答:groupBy 后 fold/reduce,或 groupingBy eachCount/eachSum。
04.8.1.4-096 分区与分组实战:按类别聚合统计怎么写?
一句话结论
groupBy 按类别分组为 Map,再对各组列表 mapValues 做 count/sum/max 聚合;二分分类用 partition 拆两个列表。
概念解释
分组聚合两步:先归类,再统计。聚合值可以是数量、求和、极值或列表;结果 Map 键为类别,值为统计结果。
原理流程
- groupBy 提取类别键。
- 各组列表累积元素。
- mapValues 对每组聚合。
- 返回类别到统计值的 Map。
代码或图示
data class Sale(val category: String, val amount: Int)
val byCategory = sales.groupBy { it.category }
.mapValues { (_, list) -> list.sumOf { it.amount } }
val (big, small) = sales.partition { it.amount > 1000 }
常见误区
- 分组后直接遍历值列表,遗漏聚合步骤。
- 类别可空导致 Map 键为 null:需处理空类别。
追问
- 答:分组后取每组极值?答:maxBy/minBy 或 maxOf/minOf 作用于组列表。
- 答:保持插入顺序?答:Linked 实现按加入顺序,具体以标准库实现为准。
04.8.1.4-097 作用域函数在初始化块中有哪些替代写法?
一句话结论
初始化逻辑可放构造参数默认值、init 块、apply 装配或局部变量分步赋值;作用域函数只是封装写法,替代方案按职责与可读性选择。
概念解释
apply 是对象装配的语法糖,不是唯一初始化方式。必填校验进构造/工厂,属性默认值进声明,跨成员配置进 apply;复杂初始化保持分步语句更清晰。
原理流程
- 必填不变量:构造参数与校验。
- 简单默认值:属性初始值。
- 多成员装配:apply 块。
- 复杂流程:局部变量分步处理。
代码或图示
// 替代 apply:构造参数 + init
class Router(val routes: List<Route>) {
init { require(routes.isNotEmpty()) }
}
// 或 apply 装配
val router = Router(emptyList()).apply { /* 补充配置 */ }
常见误区
- 用 apply 包裹必填校验:构造期契约更合适。
- 复杂初始化硬塞进作用域块:调试困难。
追问
- 答:init 块与 apply 执行顺序?答:构造参数/初始化器先执行,apply 在实例创建后调用。
- 答:属性延迟初始化用什么?答:lazy 委托或 lateinit,按可空性与注入方式选。
04.8.1.4-098 跨语言边界:null 传入 Java 方法的崩溃点如何排查?
一句话结论
Kotlin 可空值传给非空 Java 参数属于边界风险;崩溃通常出现在 Java 方法内部解引用或 Kotlin 拆箱点,排查沿调用参数回溯空值来源并在调用前校验。
概念解释
Java 方法签名不强制空检查,传入 null 后内部解引用崩溃。Kotlin 侧若平台类型未收口,空值可能跨过边界。修复在调用前判空或校验,而非崩溃行兜底。
原理流程
- 堆栈定位崩溃方法是 Java 内部还是 Kotlin 拆箱点。
- 回溯参数来源到 Kotlin 变量/Java 返回值。
- 确认空值产生路径与缺失校验。
- 调用前判空、兜底或显式失败,补测试。
代码或图示
// 风险:name 可能为 null 传入 Java 非空期望方法
javaService.save(name ?: "")
常见误区
- 只在崩溃点加断言:空值进入 Java 内部后不可控。
- 忽略包装类型拆箱空值:拆箱 NPE 出现在 Kotlin 侧。
追问
- 答:Java 方法参数空性如何确认?答:查看空性注解与实现,证据不足按可空处理。
- 答:防御层放哪里?答:Kotlin 适配层收口,不把空值透传到 Java SDK。
04.8.1.4-099 集合 API 选型:按下标操作还是按元素操作?
一句话结论
需要位置访问、索引遍历时用下标/indices/withIndex;按内容匹配、条件查找用元素谓词方法;随机访问密集选数组/ArrayList,顺序流式处理用迭代器或 Sequence。
概念解释
API 选择取决于访问模式:索引操作保留位置信息,元素操作聚焦值匹配。集合类型与操作方式匹配才能避免越界与低效遍历。
原理流程
- 判断是否需要位置序号。
- 需要索引:indices、withIndex、elementAt。
- 只看元素:filter/find/map/any 等谓词方法。
- 随机访问选连续存储集合,流式选惰性序列。
代码或图示
for ((index, value) in list.withIndex()) {
println("$index: $value")
}
val match = list.firstOrNull { it.startsWith("k") }
常见误区
- 无序 Set 用 indexOf:下标语义不适用。
- 条件查找手动循环遍历:优先标准库谓词方法。
追问
- 答:elementAt 越界怎么办?答:用 elementAtOrNull 兜底,避免越界异常。
- 答:Map 按下标还是按键?答:Map 按键取值,无位置下标概念。
04.8.1.4-100 本页知识如何串联支撑工程落地?
一句话结论
集合模型定义数据容器与只读/可变边界,Sequence 处理大数据惰性链路,作用域函数组织初始化与变换,互操作规则保证跨语言边界安全;四者配合完成 Kotlin 工程的数据处理落地。
概念解释
选型链条:先定集合可变性与元素空性,再按数据规模选即时/惰性链,用作用域函数组织代码,跨 Java 边界收口平台类型与注解。最终代码类型安全、边界清晰、性能可评估。
原理流程
- 建模:只读/可变集合、元素与容器可空性。
- 处理:小数据即时链,大/无限数据 Sequence。
- 组织:apply/let/also 等作用域函数。
- 互操作:平台类型收口、注解映射、异常与装箱边界。
代码或图示
val result = source.asSequence()
.filterNotNull()
.map { it.toDomain() }
.toList()
.also { log.info("loaded ${it.size}") }
常见误区
- 只记 API 不评估可变性、空性与互操作边界。
- 惰性/即时、作用域选型脱离数据规模与场景。
追问
- 答:本页与泛型章节衔接什么?答:集合型变标注、函数类型型变与通配符映射。
- 答:本页与 OOP 章节衔接什么?答:data class 集合属性、只读视图封装与不可变建模。
参考来源
- Kotlin 官方文档:Collections Overview — 集合接口、只读与可变模型。
- Kotlin 官方文档:Sequences — 惰性序列模型与中间/末端操作。
- Kotlin 官方文档:Scope Functions — let/run/with/apply/also 选型与返回值。
- Kotlin 官方文档:Java Interop — 平台类型、注解与互操作签名。
- Kotlin 官方文档:Annotations — 互操作注解与注解目标。
待整理清单
- [ ] 在项目 Kotlin 2.x 版本上核对标准库集合实现类型与不可变保证
- [ ] 核对 Sequence 多次遍历行为与可重复遍历的来源类型
- [ ] 补充目标框架(Spring/序列化/ORM)的集合与泛型互操作实测记录
- [ ] 整理 try-with-resources 与
use在异常路径下的关闭行为版本结论