序列（Sequence）与惰性求值

1. 什么是序列？

序列（Sequence）是 Kotlin 中表示惰性集合操作的一种方式，类似于 Java 的 Stream。它允许对集合元素进行链式操作（如 map、filter 等），但不会立即执行计算，而是在最终需要结果时才进行求值（惰性求值）。

序列的特点：

  • 惰性执行：操作按需计算，避免中间结果的生成。
  • 高效处理大数据集：减少内存占用，适合处理大规模数据。
  • 链式操作：支持类似集合的转换和过滤操作。

2. 创建序列的方式

2.1 通过 sequenceOf 直接创建

val numbers = sequenceOf(1, 2, 3, 4, 5)

2.2 通过集合转换

使用 asSequence() 将现有集合（如 List）转为序列：

val list = listOf(1, 2, 3)
val sequence = list.asSequence()

2.3 通过生成器函数

使用 generateSequence 动态生成序列：

// 生成无限序列（需限制操作）
val infiniteSequence = generateSequence(0) { it + 1 }

// 有限序列（直到 null 为止）
val finiteSequence = generateSequence(1) { if (it < 10) it * 2 else null }

3. 惰性求值的优势

3.1 避免中间集合的创建

对比集合操作（如 List）和序列操作：

// 集合操作：每一步生成中间结果
listOf(1, 2, 3).map { it * 2 }.filter { it > 3 } // 生成两个临时 List

// 序列操作：无中间结果
listOf(1, 2, 3).asSequence().map { it * 2 }.filter { it > 3 }.toList()

3.2 性能优化示例

处理大数据集时，序列可以显著减少内存和时间开销：

// 集合操作：立即执行所有步骤
(1..1_000_000).toList()
    .map { it * 2 }      // 生成 100 万个元素的临时列表
    .filter { it % 3 == 0 } // 再次生成临时列表

// 序列操作：按需计算
(1..1_000_000).asSequence()
    .map { it * 2 }      // 惰性计算
    .filter { it % 3 == 0 } // 惰性计算
    .take(10)           // 只处理前 10 个元素
    .toList()

4. 序列的操作与终止

4.1 中间操作（惰性）

  • 如 map、filter、flatMap 等，不会立即执行。
  • 返回一个新的序列。

4.2 终止操作（触发求值）

  • 如 toList()、sum()、forEach 等，会触发实际计算。
  • 必须调用终止操作才能获取结果。
val result = sequenceOf(1, 2, 3)
    .map { it * 2 }      // 未执行
    .filter { it > 2 }   // 未执行
    .toList()            // 触发计算，返回 [4, 6]

5. 使用场景与注意事项

5.1 适合场景

  • 大数据集处理（避免内存溢出）。
  • 复杂链式操作（减少中间结果）。
  • 无限序列（如斐波那契数列）。

5.2 注意事项

  • 小数据集可能因惰性开销反而性能更低。
  • 调试时需注意操作是否已执行。

6. 示例：斐波那契数列

val fibonacci = generateSequence(Pair(0, 1)) { 
    Pair(it.second, it.first + it.second) 
}.map { it.first }

println(fibonacci.take(10).toList()) // 输出 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

提示：序列是 Kotlin 函数式编程的重要工具，合理使用可以提升代码效率和可读性！

Last Updated::