探索 Kotlin 的不可变集合库

Kotlin 的标准集合（List, Set, Map）默认是可变的，这可能导致未预期的修改。为了在 API 层强制实现不可变性，JetBrains 引入了 Kotlin 不可变集合库。该库提供了一组真正不可变的集合类型，可以防止意外修改，并增强在并发或多线程环境中的安全性。

为什么使用不可变集合？

虽然 Kotlin 已经提供了 listOf()、setOf() 和 mapOf() 用于只读集合，但它们并非真正不可变。如果这些集合在其他地方被引用，其底层集合仍可能被修改。例如：

kotlin 复制代码

val list = mutableListOf("A", "B", "C")
val readOnlyList: List<String> = list  
list.add("D")  // 修改原始列表  
println(readOnlyList) // 输出: [A, B, C, D]  

(readOnlyList as MutableList).add("E")
println(readOnlyList) // 输出: [A, B, C, D, E]

为了解决这个问题，Immutable Collections 库提供了在运行时保证不可变性的集合。

关键特性

真正不可变 ------ 一旦创建，就无法被修改。
多线程安全 ------ 避免在并发环境中出现意外的修改。
性能优化 ------ 通过结构共享来防止不必要的复制。

如何使用 Kotlin 不可变集合

1. 添加依赖项

首先，在你的 build.gradle.kts 中包含 Immutable Collections 依赖项：

java 复制代码

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-collections-immutable:0.4.0")
}

2. 创建不可变集合

该库提供了 persistentListOf()、persistentSetOf() 和 persistentMapOf() 来创建不可变集合：

kotlin 复制代码

import kotlinx.collections.immutable.*

val immutableList = persistentListOf("A", "B", "C")
val immutableSet = persistentSetOf(1, 2, 3)
val immutableMap = persistentMapOf("key1" to 100, "key2" to 200)

3. 添加和移除元素

由于这些集合是不可变的，修改操作返回一个新的修改后的副本，而不是更改原始集合：

kotlin 复制代码

val newList = immutableList.add("D") // 创建一个新列表
println(newList)  // 输出: [A, B, C, D]

val newMap = immutableMap.put("key3", 300)
println(newMap)   // 输出: {key1=100, key2=200, key3=300}

原始的 immutableList 和 immutableMap 保持不变！

性能考虑

与普通的不可变集合（修改时需要完整复制）不同，持久集合使用结构共享。这意味着修改会创建一个新的集合，同时复用原始集合中未改变的部分，从而提高性能和内存效率。

例如，向一个持久化列表添加一个元素不会创建完整的副本，而是重用大部分现有结构：

code 复制代码

Original:  [A, B, C]  
New List:  [A, B, C, D] (仅"D"是新分配的)

这使得不可变集合即使在处理大型数据集时也非常高效。

Compose 中的优势

不可变集合在 Jetpack Compose 中特别有用，因为它们优化了状态管理和重组。在 Compose 应用程序中，它们的重要性体现在以下方面：

1. 避免不必要的重组

Compose 会跟踪状态变化以决定何时重组 UI 元素。
可变列表、集合或映射可能会触发不必要的重组，即使数据并未发生变化。
不可变集合确保状态保持稳定，防止不必要的重新组合。

示例：

kotlin 复制代码

@Composable
fun MyListScreen(items: List<String>) {
    LazyColumn {
        items(items) { item ->
            Text(text = item)
        }
    }
}

如果 items 是一个可变列表，即使重新分配相同的值也会触发重组。使用不可变集合如 PersistentList 可以确保 Compose 能够识别数据是否未发生变化：

kotlin 复制代码

val items = remember { persistentListOf("A", "B", "C") }
MyListScreen(items)

2. 状态稳定性以提高性能

Compose 通过跳过重组来优化渲染，当状态对象是稳定的时。
不可变集合使用结构共享，这意味着修改只会影响改变的部分，而其余部分则被复用。
这在大型列表或复杂的 UI 层次结构中能带来更好的性能。

3. 可预测的 UI 行为

由于不可变集合在创建后不能被修改，它们可以防止意外的变异，从而避免导致不可预测的 UI 更新。
这在状态驱动架构（MVI、Redux 等）中尤其有用，确保只有在必要时才更新 UI。

4. 线程安全

在使用协程（Flows、LiveData 等）的 Compose 应用中，不可变集合可以防止多个线程更新状态时出现竞态条件。
它们确保在 ViewModels、仓库和 UI 组件之间安全地传递数据。

何时使用不可变集合？

✅ 函数式编程 -- 鼓励使用不可变性以实现更安全的数据转换。
✅ 线程安全 -- 防止在多线程环境中出现意外的修改。
✅ 防止错误 -- 减少由于意外修改而导致的不可预见的副作用。
✅ 状态管理 -- 有助于优化重组并提升 UI 性能。

结论

Kotlin 的不可变集合库提供了真正不可变、高效且安全的集合，使它们成为函数式编程、并发应用和 Jetpack Compose 开发的理想选择。通过使用持久化集合，你可以编写更安全且可预测的 Kotlin 代码。

原文链接

探索 Kotlin 的不可变集合库