罗罗编程学习记录
本页内容 展开查看

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 按键存取值。接口只读不代表底层不可变,见后续题目。

原理流程

  1. Collection 声明通用集合能力。
  2. List/Set 继承 Collection 并约束顺序与重复规则。
  3. Mutable* 接口追加写入、删除、替换方法。
  4. 工厂函数返回对应接口的实现实例。

代码或图示

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,但同一底层实例可能被可变引用修改。需要真正不可变时使用工厂返回的只读实现并避免泄露可变引用。

原理流程

  1. 声明只读类型变量引用底层集合。
  2. 只读接口方法表无写入操作。
  3. 可变接口引用可调用 add/remove/set。
  4. 两处引用指向同一实例时,修改互相可见。

代码或图示

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 接口使用。不同元素数量与空集合可能使用优化实例;不要在业务代码中依赖具体实现类名。

原理流程

  1. 工厂函数按参数创建底层实现。
  2. 空集合返回优化实例。
  3. 非空集合按标准库策略选择实现。
  4. 外部通过接口方法访问。

代码或图示

val a = listOf("x", "y")
val b = mutableListOf(1, 2, 3)

常见误区

  • 反射断言返回具体 ArrayList 类型:实现可能随版本调整。
  • 把可变工厂结果赋给只读类型后又需要修改:应保留可变引用。

追问

  • 答:空集合有必要复用吗?答:标准库空集合通常共享优化实例,业务中 emptyList() 表达空值语义。
  • 答:setOf/mapOf 同理吗?答:同理,返回对应只读接口实现。

04.8.1.4-004 为什么只读集合接口不保证底层不可变?

一句话结论

只读接口只限制调用方可见的方法集合,不复制底层数据;同一实例可被可变引用、内部封装或后续修改影响,因此「只读」是视图约束而非深度冻结。

概念解释

JDK 不可变集合(如 List.of)在实现层拒绝修改;Kotlin 只读接口主要是类型层视图。工程中需要防外部误改时,应封装内部可变状态并暴露只读视图,必要时复制快照。

原理流程

  1. 底层集合对象创建后可被修改。
  2. 只读引用只暴露读取方法。
  3. 可变引用或对象内部方法可改底层。
  4. 只读引用观察到底层变化。

代码或图示

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 按元素增删。批量操作基于集合内容比较。

原理流程

  1. 单元素添加:add/put。
  2. 批量添加:addAll/putAll。
  3. 删除:remove/removeAll/clear。
  4. 保留交集: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。

原理流程

  1. 有参工厂按元素创建集合。
  2. 无参工厂返回共享空实例。
  3. emptyXxx() 显式标注空集合意图。
  4. 目标类型推断元素/键值类型。

代码或图示

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?>? 两层都可空。类型后缀位置决定语义层级。

原理流程

  1. 外层可空:调用集合方法前安全调用 ?.。
  2. 内层可空:遍历元素后判空或过滤。
  3. 组合类型两层约束叠加。
  4. 不可混淆两层 ? 位置。

代码或图示

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> 是引用数组。

原理流程

  1. List:可变/只读接口,元素数量可变化。
  2. Array:长度固定,下标访问。
  3. 原始数组按基础类型连续存储。
  4. 两者可通过转换方法互转。

代码或图示

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> 元素为引用。数组工厂函数名与类型对应,下标访问与长度属性与其他语言数组一致。

原理流程

  1. 原始类型工厂创建专用数组。
  2. 引用类型工厂创建泛型数组。
  3. 下标读写 arr[i]。
  4. 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 调用点。

原理流程

  1. 解析 Java 方法签名,无空性注解。
  2. 生成平台类型集合。
  3. 赋给非空变量:编译器放行但运行时空检查。
  4. 为空时解引用抛 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;复制后新旧容器独立,元素引用本身按引用共享。

概念解释

复制是浅拷贝:容器结构独立,元素引用不复制。可变元素对象修改仍会互相可见;需要深拷贝需单独复制元素。

原理流程

  1. 遍历源容器元素。
  2. 写入新容器实例。
  3. 新旧容器增删互不影响。
  4. 元素引用指向同一对象。

代码或图示

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 减少分配。

原理流程

  1. 集合链:每步遍历输入生成新集合。
  2. Sequence:中间操作返回新序列,保存步骤。
  3. 末端操作触发迭代,逐元素穿过所有步骤。
  4. 无中间集合副本,仅持有当前元素。

代码或图示

// 即时: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 由一系列中间操作与末端操作组成;中间操作返回新序列并记录变换,末端操作启动迭代,元素逐个流经各步骤,末端才产出最终结果。

概念解释

惰性模型把「构建处理链」与「执行计算」分开。每个元素到达末端前经过全部中间步骤,中间不落地为集合;无限序列只能通过末端受限遍历消费。

原理流程

  1. asSequence/sequenceOf 生成初始序列。
  2. 中间操作装饰出带步骤的新序列。
  3. 末端操作(toList、first、count 等)触发迭代。
  4. 逐元素执行步骤链并产出结果。

代码或图示

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 降低中间分配。实测应对比分配量、耗时与最终内存。

原理流程

  1. 集合链:中间集合数量 = 操作步数,元素重复复制。
  2. Sequence:仅末端结果落地,过程持有当前元素。
  3. 惰性调度增加函数调用与迭代器开销。
  4. 数据规模越大,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。

原理流程

  1. sequenceOf:固定元素序列。
  2. asSequence:包装已有集合为惰性视图。
  3. sequence { yield(value) }:构建器协程式产出。
  4. 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 转集合更合适。

原理流程

  1. 评估数据规模与是否有限。
  2. 大/无限且链式处理:选 Sequence。
  3. 结果复用或随机访问:转 List。
  4. 末端操作必须有界,避免无限阻塞。

代码或图示

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 为末端。链中必须有末端操作才会实际计算;中间操作可继续装饰序列。

原理流程

  1. 初始序列来源。
  2. 中间操作记录变换步骤。
  3. 末端操作请求元素并驱动遍历。
  4. 计算结果在末端落地。

代码或图示

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() 固化结果最稳妥。

原理流程

  1. 首次末端遍历消费迭代器元素。
  2. 迭代器到达末尾后不可重置。
  3. 第二次遍历无元素或按来源重新生成。
  4. 多次使用先收集为 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 内容。

原理流程

  1. 按键哈希查找条目。
  2. 存在:返回关联值。
  3. 不存在:按方法返回 null、lambda 默认或固定默认。
  4. 写入用 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;重复键按构建规则覆盖或保留。

原理流程

  1. key to value 生成 Pair。
  2. mapOf 接收 Pair 序列。
  3. 按键去重,冲突按工厂规则处理。
  4. 返回只读 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 后改字段,哈希变化导致元素无法找回。

原理流程

  1. 加入元素计算哈希定位桶。
  2. 桶内按 equals 比较。
  3. 相等则不重复加入,不等则追加。
  4. 查找与移除按相同契约。

代码或图示

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 类型在哈希表外串联条目链表,插入顺序可预测。遍历、展示与需要顺序稳定的场景使用;元素重排不改变链表顺序。

原理流程

  1. 哈希表按键定位条目。
  2. 链表按插入顺序串联条目。
  3. 迭代沿链表返回。
  4. 移除条目同步解除链表链接。

代码或图示

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 或先过滤再排序。

原理流程

  1. 选择器提取可比较键。
  2. 自然顺序或定制比较器排序。
  3. 空值按比较器规则定位。
  4. 返回新排序集合,原集合不变。

代码或图示

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 两组。两者都不修改原集合,返回新集合结构。

原理流程

  1. 遍历元素提取分组键或谓词结果。
  2. groupBy 累积到 Map 对应列表。
  3. partition 累积到两个固定列表。
  4. 返回分组映射或二元组。

代码或图示

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 产出累积过程列表,用于观察中间状态。

原理流程

  1. fold:初始值 → 逐项合并 → 最终累积值。
  2. reduce:首元素为初始值 → 逐项合并。
  3. scan:每步累积结果加入序列。
  4. 集合即时执行,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 等统计。

原理流程

  1. 嵌套列表 flatten 拍平一层。
  2. flatMap 元素 → 集合 → 合并结果。
  3. groupBy 得到分组 Map。
  4. 各组列表聚合为统计结果。

代码或图示

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 避免异常。

原理流程

  1. 元素查找:遍历比较相等性返回首个/末个下标。
  2. 谓词查找:匹配条件返回下标。
  3. 下标取值:检查范围后返回元素。
  4. 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 变体;确定存在或唯一时用严格方法,失败即暴露数据问题。

原理流程

  1. 遍历元素匹配谓词。
  2. first 类:取首个匹配。
  3. single 类:统计匹配数量,唯一才返回。
  4. 无匹配/多匹配按方法返回 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,符合逻辑量词规则。结果可用于校验与存在性判断。

原理流程

  1. 遍历元素应用谓词。
  2. all 遇不满足即返回 false。
  3. none 遇满足即返回 false。
  4. 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 谓词相比,类型推断自动收窄元素类型。

原理流程

  1. 遍历元素判断是否为 null。
  2. 非空元素加入结果。
  3. 结果元素类型收窄为非空 T。
  4. 容器可空性由外层 ?. 处理。

代码或图示

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> 无法区分。

原理流程

  1. 遍历元素检查类型归属。
  2. 匹配元素加入结果并强转。
  3. 不匹配跳过。
  4. 泛型实参类型擦除后不可判断。

代码或图示

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();不要在同一条链上反复互转。

概念解释

互转边界决定中间分配:集合进序列消除后续中间集合,序列出集合固化结果。频繁来回转换会抵消惰性收益并增加复制成本。

原理流程

  1. 大集合长链:先 asSequence 再链式处理。
  2. 末端结果固化:toList/toSet。
  3. 复用结果对集合多次操作。
  4. 避免链中 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 计算结果。

原理流程

  1. 函数接收接收者与 lambda。
  2. 绑定接收者为 this 或参数 it。
  3. 执行 lambda 体。
  4. 返回 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 是接收者上下文,成员访问可省略前缀。选择引用方式取决于内部写法习惯与消歧需要。

原理流程

  1. let/also:lambda 签名 (T) -> R,接收者为 it。
  2. run/with/apply:lambda 为 T.() -> R,接收者为 this。
  3. 成员访问按对应引用解析。
  4. 多接收者嵌套时用限定 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 结果适合在作用域内做变换并取结果。误用会导致链式下一步类型错误。

原理流程

  1. apply/also:执行后返回接收者 T。
  2. let/run/with:返回 lambda 表达式结果 R。
  3. 链式下一步按返回类型匹配方法。
  4. 需要对象继续配置用 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 最后一行,类型由变换结果决定。

原理流程

  1. 接收者可空时先 ?. 判空。
  2. 非空进入 let lambda,it 为接收者。
  3. 内部执行变换并返回结果。
  4. 整体结果类型为可空(空分支为 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。

原理流程

  1. 接收者作为 this 传入 lambda。
  2. 内部调用成员、做计算。
  3. 返回 lambda 最后一行结果。
  4. 空接收者配合 ?. 跳过。

代码或图示

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 访问成员,把相关操作聚合在一个块内。

原理流程

  1. 显式传入接收者对象。
  2. lambda 内 this 绑定该对象。
  3. 多条成员调用集中书写。
  4. 返回 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 不返回计算结果,返回配置好的接收者。适合「创建即配置」的场景:属性赋值、监听器挂载、初始状态设置。

原理流程

  1. 创建对象实例。
  2. apply 把实例作为 this 传入。
  3. 块内设置属性与状态。
  4. 返回原实例,可继续链式传递。

代码或图示

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 区别在引用方式与用途侧重。

原理流程

  1. 链式主链得到对象。
  2. also 传入对象为 it。
  3. 块内执行副作用动作。
  4. 返回原对象,主链类型不变。

代码或图示

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。

原理流程

  1. 是否需要返回对象本身:是 → apply/also;否 → let/run/with。
  2. 内部用 this 还是 it:this → run/with/apply;it → let/also。
  3. 是否需要链式安全调用:let/run 支持 ?.,with 不支持。
  4. 按场景确定最终函数。

代码或图示

返回对象本身: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)把链类型切换为结果类型,下一步只能调用结果类型方法。

概念解释

链式下一步可用方法由上一步返回类型决定。误用返回值会导致后续方法不存在或类型不匹配;阅读链式代码先标注每步返回类型。

原理流程

  1. apply/also 输出接收者类型 T。
  2. let/run/with 输出 lambda 结果类型 R。
  3. 链式下一步按输出类型解析方法。
  4. 类型不兼容编译报错。

代码或图示

// 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。需要默认值时外层再叠 ?:。

原理流程

  1. 接收者为 null:短路,表达式结果 null。
  2. 非空:进入 let,it 类型收窄非空。
  3. lambda 返回变换结果。
  4. 整体类型为结果可空形式。

代码或图示

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。解析顺序由内向外,歧义时显式限定。把外层接收者存入命名变量是最稳妥的消歧方式。

原理流程

  1. 外层块绑定接收者 A。
  2. 内层块绑定接收者 B。
  3. 成员查找先匹配 B,再沿链找 A。
  4. 限定 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。评审时应判断去掉作用域块后代码是否更直接。

原理流程

  1. 识别作用域块是否承担分组/安全/配置职责。
  2. 单步变换可直接表达式书写。
  3. 副作用穿插优先独立语句。
  4. 嵌套层级控制在必要范围。

代码或图示

// 反例:过度嵌套
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 源码显式写出。集合本身与元素空性都可能未知,需要在适配层显式收口。

原理流程

  1. 解析 Java 方法/字段签名。
  2. 无空性注解 → 生成平台类型。
  3. 赋给非空变量:编译放行,运行时空检查。
  4. 为空解引用抛 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> 表示元素可空;方法返回值本身空性由返回位置注解决定。层级标注缺失会留下平台类型。

原理流程

  1. 读取方法返回、参数、字段注解。
  2. 明确注解映射为确定类型。
  3. 缺失位置生成平台类型。
  4. 泛型实参按其位置注解独立判断。

代码或图示

@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。映射位置由可空性与使用场景决定,跨边界注意装箱成本。

原理流程

  1. 非空局部/参数/返回值:原始类型。
  2. 可空声明:包装类。
  3. 泛型容器元素:包装类。
  4. 跨语言调用按 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 复制隔离。

原理流程

  1. Java 方法返回内部集合引用。
  2. Kotlin 外部持有同一引用。
  3. 外部修改影响 Java 对象内部状态。
  4. 需要隔离时复制为新集合。

代码或图示

// 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 使用。

原理流程

  1. Kotlin 声明带默认值参数。
  2. 加 @JvmOverloads。
  3. 编译器按默认位置生成重载方法/构造器。
  4. 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 签名本身不携带默认值。生成重载只是转发到主签名,默认值表达式在转发点求值。

原理流程

  1. 主签名保留全部参数。
  2. 注解生成省略尾部默认参数的重载。
  3. 重载内部调用主签名并补默认值。
  4. 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 调用、反射与堆栈问题。

原理流程

  1. 顶层函数写入源文件。
  2. 编译器生成文件包装类。
  3. 函数成为包装类静态方法。
  4. @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 可见名可以不同。

原理流程

  1. 文件级注解指定包装类名。
  2. 函数级注解指定静态方法名。
  3. 编译器按注解生成签名。
  4. 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 之外受限场景,具体约束以编译器规则为准。

原理流程

  1. 属性标注 @JvmField。
  2. 编译器生成公开字段。
  3. Java 直接字段读写,不经过访问器。
  4. 封装与校验逻辑不能挂在该字段上。

代码或图示

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 两种调用形式都可见。

原理流程

  1. 伴生对象声明方法/属性。
  2. 标注 @JvmStatic。
  3. 编译器生成静态转发成员。
  4. 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 是对应建模方式。跨语言映射、注解标记与框架支持在不同版本存在差异,属于待确认点。

原理流程

  1. 记录项目 Kotlin 与 JDK 版本。
  2. 查官方文档对 record 互操作的说明。
  3. 最小工程编译验证生成签名与框架反序列化。
  4. 不确定结论标注「待确认」与验证步骤。

代码或图示

// 待确认:目标版本 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 规则与签名可见性判断。

原理流程

  1. Kotlin 函数体抛异常无需 throws 声明。
  2. 字节码异常表按实际抛出记录。
  3. Java 侧调用时检查受检异常声明可见性。
  4. 未声明的受检异常在 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 签名中可见性受注解与字节码影响。

原理流程

  1. Kotlin 函数抛出受检异常。
  2. 编译产物保留异常抛出信息。
  3. Java 调用方按规则检查是否需要捕获/声明。
  4. 行为不确定处标注待确认并实测。

代码或图示

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 框架或调用方要求固定实参签名。注解在类、方法、参数或类型位置调整通配符生成规则。

原理流程

  1. 编译导出 Java 签名时按型变生成通配符。
  2. Suppress 注解去除不必要通配符。
  3. Wildcard 注解显式标注通配符。
  4. 框架按固定签名解析类型。

代码或图示

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 支持范围以版本为准。

原理流程

  1. 目标位置为 Java 单方法接口。
  2. lambda 按接口方法签名推断参数与返回。
  3. 编译器生成接口实现实例。
  4. 调用接口方法时执行 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 按其签名适配。

原理流程

  1. 检查函数类型参数与返回方向。
  2. 消费型对应 Consumer 一类接口。
  3. 转换型对应 Function 一类接口。
  4. 无参无返回对应 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 命名按规则生成。框架按访问器约定识别属性。

原理流程

  1. val 属性生成 getter。
  2. var 属性生成 getter + setter。
  3. 方法名按属性名前缀规则拼接。
  4. 标注 @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 必须位于顶层或伴生对象,初始值为编译期表达式。

原理流程

  1. 常量初始值编译期可求值。
  2. 引用处替换为字面量。
  3. Java 调用点不访问字段。
  4. 修改常量需重新编译调用方。

代码或图示

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 侧共享同一可变状态,需在设计层保护。

原理流程

  1. var 属性生成 getter/setter。
  2. 多线程并发读写同一属性。
  3. 无同步时可见性与竞争不确定。
  4. 按需使用同步方法、@Volatile 或并发集合。

代码或图示

class Counter {
    var count: Int = 0 // 跨线程访问需同步保护
}

常见误区

  • 以为 Kotlin 属性自动线程安全:关键字不提供同步。
  • 可变公开属性被框架并发改写:封装边界缺失。

追问

  • 答:@Volatile 作用是什么?答:保证变量读写可见性,不保证复合操作原子性。
  • 答:推荐的可变状态封装?答:私有可变字段 + 受控方法,方法内同步或用并发结构。

04.8.1.4-065 Java 如何调用 Kotlin 扩展函数?

一句话结论

扩展函数编译为静态工具方法,首参为接收者;Java 不能在实例上点号调用扩展,需按生成的工具类静态方法传入接收者。

概念解释

扩展不写入原类方法表,Java 反射与实例方法列表看不到。顶层扩展归属文件包装类,成员扩展归属对应类/伴生对象,调用签名按编译产物确定。

原理流程

  1. 扩展编译为静态函数,接收者为首参。
  2. Java 按包装类静态方法调用。
  3. 传入接收者实例与其余参数。
  4. 调用方不能按 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 兼容性;通配符过多可能影响框架反序列化与类型推断,必要时用注解抑制。

原理流程

  1. 编译器按 Kotlin 型变生成 Java 泛型签名。
  2. 协变位置导出 ? extends T。
  3. 逆变位置导出 ? super T。
  4. 框架按通配符限制读写位置。

代码或图示

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 侧呈现对应数组类型,转换需专用方法。

原理流程

  1. 专用数组工厂生成原始类型数组。
  2. 泛型数组生成引用数组。
  3. 跨语言调用按签名类型传递。
  4. 互转通过 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。

原理流程

  1. 字符串两侧类型一致。
  2. 非空基本类型传原始值。
  3. 可空/泛型位置装箱为包装类。
  4. 包装为空时拆箱解引用抛 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,两层分别处理,关键结果用校验函数提升非空。

原理流程

  1. 调用 SDK 方法,结果赋给 List<T>?。
  2. 容器判空后遍历,元素判空或过滤。
  3. 契约必填结果用 requireNotNull 校验。
  4. 业务层只接触确定可空/非空类型。

代码或图示

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 访问器与集合类型。暴露只读集合减少误改;框架需要填充集合时返回可变实例。泛型签名按框架反序列化要求核对。

原理流程

  1. 确认框架读取还是写入集合。
  2. 只读场景暴露 List/Set/Map 视图。
  3. 写入场景提供 MutableCollection 实例。
  4. 核对泛型通配符、可空性与注解兼容。

代码或图示

data class ApiResponse(
    val items: List<Item> = emptyList()
)

常见误区

  • 暴露内部可变集合引用给框架:外部可改内部状态。
  • 忽略框架泛型反序列化要求:类型解析失败。

追问

  • 答:框架需要无参构造怎么办?答:data class 默认值与构造配置按框架要求评估,必要时补注解。
  • 答:集合空性文档怎么写?答:明确集合是否可能为 null、元素是否可空,与签名一致。

04.8.1.4-071 场景:大日志或数据流如何选择 Sequence 还是集合?

一句话结论

数据量大、来源流式、链路长时用 Sequence 逐元素流过;结果需要多次复用、随机访问或数据量小、链路短时用普通集合。

概念解释

日志文件、消息流、大查询结果适合惰性处理,避免中间集合撑爆内存;缓存后反复计算的结果固化为 List。选型结合末端结果大小与遍历次数。

原理流程

  1. 评估数据规模、是否有限、遍历次数。
  2. 大/无限 + 单遍链式处理:Sequence。
  3. 结果复用或下标访问:toList 固化。
  4. 小数据短链:直接集合链更直观。

代码或图示

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 在实例创建后配置,适合框架注入、监听器注册。简单默认值优先构造器,避免无意义作用域嵌套。

原理流程

  1. 识别属性是否必填、有无默认值。
  2. 基本属性进构造参数。
  3. 可选装配逻辑进 apply 块。
  4. 返回配置完成的实例。

代码或图示

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 内改值期待带出。

原理流程

  1. 主链得到当前对象。
  2. also 传入对象为 it。
  3. 块内执行日志/校验副作用。
  4. 返回原对象继续主链。

代码或图示

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 遍历集合逐元素转换并返回新集合。职责清晰后链式结构更易读。

原理流程

  1. 判断输入是单个对象还是集合。
  2. 单个可空对象:let 内映射字段。
  3. 集合元素:map 逐元素转换。
  4. 空值分支按 ?: 或返回 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 暂停与复制耗时累积;优化方向是减少步骤或改用惰性序列。

原理流程

  1. 每步遍历输入集合。
  2. 分配新集合容纳结果。
  3. 元素复制到新集合。
  4. 旧中间集合成为垃圾待回收。

代码或图示

// 两步操作产生两个中间 List
list.filter { it > 1 }.map { it * 2 }

常见误区

  • 只看最终结果大小,忽略中间集合数量。
  • 小数据链也追求惰性:调度开销可能不划算。

追问

  • 答:如何测量中间分配?答:对比链步骤数、对象分配热点与 GC 次数,大样本实测。
  • 答:减少中间集合的手段?答:合并相邻操作、改用 Sequence、末端按需取值。

04.8.1.4-076 性能:Sequence 为何在末端执行时不产生中间集合?

一句话结论

Sequence 中间操作只记录步骤,末端迭代时逐元素流过整条链,过程中只持有当前元素,不落地每步结果集合,因此消除中间集合副本。

概念解释

惰性模型把收集推迟到末端:每个元素先过 filter 再过 map,到达末端才被收集。内存占用从「中间集合数量 × 元素」降为当前元素加末端结果。

原理流程

  1. 中间操作装饰序列,不分配集合。
  2. 末端迭代请求元素。
  3. 单元素依次穿过步骤链。
  4. 末端结果收集为最终集合。

代码或图示

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 执行。与手写临时变量相比,差异主要是语法封装,性能敏感场景可实测对比。

原理流程

  1. 调用作用域函数传入接收者与 lambda。
  2. 函数绑定接收者并执行 lambda。
  3. 返回 lambda 结果或接收者。
  4. 无独立包装对象分配。

代码或图示

val x = value.also { log(it) }
// 等价:临时变量 + 语句 + 返回变量的手写结构

常见误区

  • 以为作用域函数有显著对象分配:通常只是函数调用。
  • 在超高频循环里嵌套多层作用域:lambda 体与转发次数累积。

追问

  • 答:with 与扩展形式性能有别吗?答:实现方式略有差异,热点路径实测即可。
  • 答:可读性与性能如何平衡?答:非热路径优先可读性,热路径手写局部变量对比实测。

04.8.1.4-078 ArrayList 与 LinkedList 如何选型?

一句话结论

随机下标访问、遍历为主选 ArrayList(连续存储);频繁首尾插入删除、节点频繁增删选 LinkedList;Kotlin 业务集合默认优先 ArrayList 实现。

概念解释

ArrayList 数组连续存储,下标访问 O(1),中间插入移动元素;LinkedList 节点串联,首尾增删快,随机访问需遍历。业务多数场景读多写少,ArrayList 更合适。

原理流程

  1. 分析访问模式:随机访问/遍历 vs 首尾增删。
  2. 连续存储选 ArrayList。
  3. 节点式增删选 LinkedList。
  4. 按元素规模与操作频率实测。

代码或图示

val array = mutableListOf(1, 2, 3) // 近似 ArrayList 实现
// 需要 LinkedList 时按标准库/Java 实现类型创建

常见误区

  • 以为 LinkedList 所有操作都更快:随机访问劣势明显。
  • 频繁中间插入用数组实现:元素移动成本高。

追问

  • 答:Kotlin mutableListOf 返回哪种实现?答:以标准库版本为准,业务代码面向 List 接口编程。
  • 答:队列/栈结构用什么?答:按标准库双端队列实现或专用集合,具体类型以版本为准。

04.8.1.4-079 坑:只读接口引用可变实现被外部改写怎么办?

一句话结论

只读引用不复制底层数据,持有同一可变实例的其他引用或内部方法仍可修改;需要防外部误改时封装内部可变状态,对外暴露只读视图或返回复制快照。

概念解释

典型泄漏:类把内部 MutableList 直接作为只读 List 返回。外部虽不能经接口改,但引用共享,后续内部修改外部可见,其他持引用方也可强转改写。

原理流程

  1. 内部持有可变集合。
  2. 方法返回内部集合只读引用。
  3. 底层被内部或其他引用修改。
  4. 只读引用观察到变化。

代码或图示

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 可反复遍历不同,序列基于迭代器消费。来源不同行为可能有差异,稳妥做法是收集为集合后多次操作,避免第二次遍历结果不确定。

原理流程

  1. 首次末端遍历消费迭代器。
  2. 迭代器到达末尾不可重置。
  3. 第二次遍历无元素或重新生成。
  4. 复用场景先转 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 后继续访问对象成员。阅读链式代码先标注每步返回类型。

原理流程

  1. 确认函数返回接收者还是 lambda 结果。
  2. 按返回类型匹配下一步方法。
  3. 类型不匹配即选型错误。
  4. 重构:配置用 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 方法签名与实现 → 空性注解 → 复现用例。

原理流程

  1. 读堆栈定位 Kotlin 解引用行。
  2. 沿赋值链回溯跨语言调用点。
  3. 检查注解与实现是否可能为空。
  4. 适配层声明可空、安全调用/校验,补测试。

代码或图示

// 崩溃: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 签名重复。冲突可能来自父类方法、同类重载或第三方接口,需核对生成签名。

原理流程

  1. 标注注解后编译器生成递减重载。
  2. 与既有方法签名比对。
  3. 重复签名编译报错。
  4. 调整参数、方法名或移除注解。

代码或图示

@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。

原理流程

  1. 按键查找条目。
  2. 无键或值为 null 都可能得到 null。
  3. 安全调用/兜底后再使用。
  4. 需要区分两种空态时检查 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 版本在编译期保留外层类型,元素实参仍擦除;把过滤结果强转为嵌套泛型容器属于未检查强转。

原理流程

  1. 遍历元素做外层类型归属判断。
  2. 匹配元素强转为目标类型。
  3. 嵌套泛型实参运行时不可得。
  4. 需要元素类型判断时逐项检查或保存令牌。

代码或图示

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 概念。

原理流程

  1. Iterable:即时生成中间集合。
  2. Stream:惰性流水线,末端操作收集,可并行。
  3. Sequence:惰性逐元素流过,末端收集。
  4. 结果语义等价,机制与 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 属于后者。工程文档需说明不可变保证层级。

原理流程

  1. Kotlin 只读引用:调用方无写入方法。
  2. 底层实例可能被可变引用修改。
  3. 实现层不可变:任何修改入口抛异常。
  4. 跨语言共享集合按实际实现判断安全性。

代码或图示

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 手写关闭。

原理流程

  1. 获取可关闭资源实例。
  2. 调用 use { } 传入处理逻辑。
  3. lambda 正常或异常结束后关闭资源。
  4. 原始异常继续传播。

代码或图示

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;不确定的实现类名、默认行为、框架兼容标注「待确认」并写验证步骤。

原理流程

  1. 记录编译器与标准库版本。
  2. 查官方文档集合与互操作章节。
  3. 最小工程编译验证签名、实现类型与行为。
  4. 无法核实处不编造版本号与类名。

代码或图示

// 待确认:目标版本集合实现类、不可变保证与新增 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 侧另行处理。

原理流程

  1. 识别 Stream 中间操作与末端收集。
  2. 逐映射为 Kotlin 集合/Sequence 操作。
  3. 末端 toList/toSet 固化结果。
  4. 补可空元素过滤与类型收窄。

代码或图示

// 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 对应什么?答:Kotlin flatMap。
  • 答:Stream reduce 对应?答:Kotlin reduce/fold,初始值策略按语义选择。

04.8.1.4-091 面试手写:为对象选择合适作用域函数并说明理由

一句话结论

按「返回对象本身还是结果 + this 还是 it」选型:配置初始化 apply,副作用穿插 also,非空变换 let,对象上计算 run,集中调用一组成员 with。

概念解释

答题先给场景,再写函数选择与代码,说明返回值类型与引用方式。能解释为什么不用其他函数,比背函数名更重要。

原理流程

  1. 判断是否需要返回对象继续传递。
  2. 判断内部引用 this 还是 it。
  3. 按决策表确定函数。
  4. 说明空安全组合(?.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 中间不落地集合。

原理流程

  1. 判定链是 Iterable 即时还是 Sequence 惰性。
  2. 即时:每步遍历当前集合生成新集合。
  3. 惰性:末端迭代,单元素穿过全部步骤。
  4. 统计中间集合数量与元素处理次数。

代码或图示

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 调用方需要什么签名形态,再选注解。注解作用位置(文件/函数/参数)与类型需对应,混淆位置不生效。

原理流程

  1. 分析 Java 侧调用方式与签名要求。
  2. 默认值重载 → JvmOverloads。
  3. 静态调用 → JvmStatic;字段访问 → JvmField。
  4. 泛型签名 → 通配符注解;命名 → 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。

原理流程

  1. 构造多键 compareBy 链。
  2. 可空键用 nullsLast/nullsFirst 包装。
  3. sortedBy/sortedWith 应用比较器。
  4. 返回排序后新集合。

代码或图示

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。重复键冲突默认覆盖,需要累加时先分组再聚合。

原理流程

  1. 遍历源集合元素。
  2. 选择键值映射方式生成 Pair。
  3. toMap/associateWith 构建 Map。
  4. 冲突按键规则覆盖或分组聚合。

代码或图示

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 键为类别,值为统计结果。

原理流程

  1. groupBy 提取类别键。
  2. 各组列表累积元素。
  3. mapValues 对每组聚合。
  4. 返回类别到统计值的 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;复杂初始化保持分步语句更清晰。

原理流程

  1. 必填不变量:构造参数与校验。
  2. 简单默认值:属性初始值。
  3. 多成员装配:apply 块。
  4. 复杂流程:局部变量分步处理。

代码或图示

// 替代 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 侧若平台类型未收口,空值可能跨过边界。修复在调用前判空或校验,而非崩溃行兜底。

原理流程

  1. 堆栈定位崩溃方法是 Java 内部还是 Kotlin 拆箱点。
  2. 回溯参数来源到 Kotlin 变量/Java 返回值。
  3. 确认空值产生路径与缺失校验。
  4. 调用前判空、兜底或显式失败,补测试。

代码或图示

// 风险:name 可能为 null 传入 Java 非空期望方法
javaService.save(name ?: "")

常见误区

  • 只在崩溃点加断言:空值进入 Java 内部后不可控。
  • 忽略包装类型拆箱空值:拆箱 NPE 出现在 Kotlin 侧。

追问

  • 答:Java 方法参数空性如何确认?答:查看空性注解与实现,证据不足按可空处理。
  • 答:防御层放哪里?答:Kotlin 适配层收口,不把空值透传到 Java SDK。

04.8.1.4-099 集合 API 选型:按下标操作还是按元素操作?

一句话结论

需要位置访问、索引遍历时用下标/indices/withIndex;按内容匹配、条件查找用元素谓词方法;随机访问密集选数组/ArrayList,顺序流式处理用迭代器或 Sequence。

概念解释

API 选择取决于访问模式:索引操作保留位置信息,元素操作聚焦值匹配。集合类型与操作方式匹配才能避免越界与低效遍历。

原理流程

  1. 判断是否需要位置序号。
  2. 需要索引:indices、withIndex、elementAt。
  3. 只看元素:filter/find/map/any 等谓词方法。
  4. 随机访问选连续存储集合,流式选惰性序列。

代码或图示

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 边界收口平台类型与注解。最终代码类型安全、边界清晰、性能可评估。

原理流程

  1. 建模:只读/可变集合、元素与容器可空性。
  2. 处理:小数据即时链,大/无限数据 Sequence。
  3. 组织:apply/let/also 等作用域函数。
  4. 互操作:平台类型收口、注解映射、异常与装箱边界。

代码或图示

val result = source.asSequence()
    .filterNotNull()
    .map { it.toDomain() }
    .toList()
    .also { log.info("loaded ${it.size}") }

常见误区

  • 只记 API 不评估可变性、空性与互操作边界。
  • 惰性/即时、作用域选型脱离数据规模与场景。

追问

  • 答:本页与泛型章节衔接什么?答:集合型变标注、函数类型型变与通配符映射。
  • 答:本页与 OOP 章节衔接什么?答:data class 集合属性、只读视图封装与不可变建模。

参考来源

待整理清单

  • [ ] 在项目 Kotlin 2.x 版本上核对标准库集合实现类型与不可变保证
  • [ ] 核对 Sequence 多次遍历行为与可重复遍历的来源类型
  • [ ] 补充目标框架(Spring/序列化/ORM)的集合与泛型互操作实测记录
  • [ ] 整理 try-with-resources 与 use 在异常路径下的关闭行为版本结论