0Pricing
Kotlin Academy · 课时

串联处理流程并使用 Sequence 避免中间列表

构建多步骤处理流程，并使用 Sequence 实现惰性求值。

串联处理流程并使用 Sequence 避免中间列表 是 CoddyKit 上的免费 Kotlin Academy 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Kotlin Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Kotlin Academy 课程共包含 4 节课。

问题：中间列表

每个集合操作（过滤、映射等）都会创建一个新列表。对于大型集合或较长的调用链，这会浪费内存和时间。

急切求值与惰性求值

集合操作是急切的：每一步都会先完整处理列表，然后才执行下一步。序列操作是惰性的：先让一个元素经过所有步骤，再处理下一个元素。

转换为序列

调用 asSequence()，即可从急切的列表处理切换为惰性的序列处理。
val result = (1..1_000_000)
    .asSequence()
    .filter { it % 2 == 0 }
    .map { it * it }
    .take(5)
    .toList()
println(result)  // [4, 16, 36, 64, 100]

序列是惰性的：终结操作之前不会执行任何工作

直到调用终结操作（toList、first、sum 等）后，才会进行计算。
val seq = generateSequence(1) { it + 1 }  // infinite!
    .filter { it % 3 == 0 }
    .map { it * it }
val first5 = seq.take(5).toList()
println(first5)  // [9, 36, 81, 144, 225]

generateSequence：无限序列

generateSequence 会创建惰性的无限序列。
val fibonacci = generateSequence(Pair(0, 1)) { (a, b) -> Pair(b, a + b) }
    .map { it.first }
val first10 = fibonacci.take(10).toList()
println(first10)  // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

序列构建器

序列 { } 构建器使用“产出”创建自定义惰性序列。
val evens = sequence {
    var n = 0
    while (true) {
        yield(n)
        n += 2
    }
}
println(evens.take(5).toList())  // [0, 2, 4, 6, 8]

何时使用序列

在以下情况下使用序列：集合很大（>1000 个元素）、使用多个串联操作，和/或只需要少量结果。

何时 NOT 使用序列

对于较小的集合（<100 个元素），序列会增加额外开销。基于迭代器的机制在较短的调用链中速度更慢。
// Overkill for small list:
listOf(1, 2, 3).asSequence().map { it * 2 }.toList()
// Just use:
listOf(1, 2, 3).map { it * 2 }

序列终结操作

终结操作会触发处理。常见操作包括：toList()、first()、last()、sum()、计数、任意、全部、无一。
val s = (1..100).asSequence().filter { it % 7 == 0 }
println(s.first())          // 7
println(s.count())          // 14
println(s.sum())            // 728

有状态操作与无状态操作

某些序列操作是有状态的（排序、去重）——它们必须看到所有元素后才能产生输出，因此会中断惰性求值。
val s = (1..10).asSequence()
    .filter { it > 3 }   // stateless: lazy
    .sorted()            // stateful: must see all elements
    .take(3).toList()
println(s)  // [4, 5, 6]

constrainOnce：单次迭代安全性

使用 constrainOnce()，可让序列在被多次迭代时抛出异常——这对流很有用。
val seq = generateSequence(1) { if (it < 5) it + 1 else null }
    .constrainOnce()
val first = seq.toList()   // OK
// val second = seq.toList()  // IllegalStateException!

快速检查

序列何时开始处理元素？

回顾

序列是惰性的——在终结操作之前不会执行任何工作。对于包含多个串联操作的大型集合，请使用 asSequence()。generateSequence 和序列 { } 可以创建无限惰性流。终结操作会触发处理。

常见问题解答

「串联处理流程并使用 Sequence 避免中间列表」课时是免费的吗？

是的 — 「串联处理流程并使用 Sequence 避免中间列表」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Kotlin Academy 课程的其余内容，请升级到 CoddyKit PRO。 Kotlin Academy 课程共包含 4 节课。

「串联处理流程并使用 Sequence 避免中间列表」这节课中我会学到什么？

构建多步骤处理流程，并使用 Sequence 实现惰性求值。 你通过在浏览器中直接运行的动手代码来练习 Kotlin Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Kotlin Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Kotlin Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。

「串联处理流程并使用 Sequence 避免中间列表」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Kotlin Academy 课中编写并运行代码吗？

能。每节 Kotlin Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. map 与 flatMap：转换每个元素
  2. filter、filterNot 与 partition
  3. fold、reduce 与 runningFold
  4. 串联处理流程并使用 Sequence 避免中间列表
← 返回 Kotlin Academy