当前位置：首页 > news >正文

Kotlin序列

news 2025/7/19 7:07:52

序列（Sequences）

序列是一种容器，其中的对象不是事先存储的，而是在迭代过程中动态生成的。 这意味着这些对象只有在真正需要使用时才会被处理：也就是说，序列是惰性执行的（lazy evaluation），每一步不会立刻产生中间结果。

序列提供了与 Iterable 相同的函数：我们可以对其进行过滤、映射、排序等操作，但在底层的实现方式上有所不同。对于 Iterable，每一步操作都对整个集合执行并返回一个新的中间集合；而对于 Sequence，每个操作都是逐个元素地链式执行，直到最终结果被请求时才真正开始处理。

这带来了两个优势：

序列可以是无限的：我们可以通过初始值和一个函数来定义一个序列，例如无限增长的数列。
避免中间集合的创建：多个操作（如过滤、转换等）在序列中是链式按需执行的，不需要每一步都生成新的集合。

创建序列的方法

1. 从元素创建

使用 sequenceOf() 函数，从给定的元素生成序列：

val sequenceOfStrings = sequenceOf("one", "two", "three", "four")
val sequenceOfInts = sequenceOf(1, 2, 3, 4)

2. 从可迭代对象（Iterable）创建

可以使用 asSequence() 将任何集合转换为序列：

val listOfStrings = listOf("one", "two", "three", "four")
val listOfInts = listOf(1, 2, 3, 4)val sequenceOfStrings = listOfStrings.asSequence()
val sequenceOfInts = listOfInts.asSequence()

解释：这会将已有的 List 或其他集合转换为 Sequence，以便惰性处理元素。

3. 从函数创建

使用 generateSequence()，它接收一个初始值（种子）和一个函数，根据规则生成一个（可能无限的）序列：

val sequenceOfEvenNumbers = generateSequence(1) { it + 1 }.filter { it % 2 == 0 }.take(5)
println(sequenceOfEvenNumbers.toList()) // [2, 4, 6, 8, 10]

解释：这段代码生成了一个从 1 开始不断加 1 的序列，过滤出偶数，并取前 5 个。

4. 从代码块分块生成

使用 sequence {} 代码块，配合 yield() 或 yieldAll() 按需产生元素：

val evenNumbersSequence = sequence {yield(2)yieldAll(listOf(4, 6))yieldAll(generateSequence(8) { it + 2 })
}
println(evenNumbersSequence.take(5).toList()) // [2, 4, 6, 8, 10]

解释：这个序列依次生成了 2，4，6，然后从 8 开始生成无限个偶数。

一、序列操作的两大分类：无状态 vs 有状态

无状态操作（Stateless）

定义：对每个元素独立处理，不依赖之前元素或上下文。

方法	用途	示例代码
`map()`	对每个元素应用变换	`sequenceOf(1, 2, 3).map { it * 2 }` → `[2, 4, 6]`
`filter()`	过滤符合条件的元素	`sequenceOf(1, 2, 3, 4).filter { it % 2 == 0 }` → `[2, 4]`
`take(n)`	取前 `n` 个元素	`sequenceOf(1, 2, 3, 4).take(2)` → `[1, 2]`
`drop(n)`	跳过前 `n` 个元素	`sequenceOf(1, 2, 3, 4).drop(2)` → `[3, 4]`

这些操作通常开销较小，并且可以尽早终止处理。

有状态操作（Stateful）

定义：需要维护中间状态（缓存、计数、排序等），通常必须遍历整个序列。

方法	用途	示例代码
`sorted()`	排序（需收集全部元素）	`sequenceOf(3, 1, 2).sorted()` → `[1, 2, 3]`
`distinct()`	去重（需跟踪已出现的值）	`sequenceOf(1, 2, 1).distinct()` → `[1, 2]`
`chunked(n)`	将序列划分为多个块	`sequenceOf(1,2,3,4,5).chunked(2)` → `[[1,2], [3,4], [5]]`

二、序列操作的阶段：中间 vs 终端

中间操作（Intermediate）

特点：惰性执行，不立刻处理元素，只是构造操作链。返回新的 Sequence。

方法	用途	示例
`map()`	转换元素	`sequence.map { it * 2 }`
`filter()`	过滤元素	`sequence.filter { it > 0 }`
`take()` / `drop()`	取/跳前几个	`sequence.take(3)`
`sorted()`	排序	`sequence.sorted()`
这些方法只有在终端操作触发时才执行！

终端操作（Terminal）

特点：触发执行，返回结果（如集合、单个值等），整个序列会被遍历或处理。

方法	用途	示例	返回值类型
`toList()`	转换为 List	`sequence.toList()`	`List<T>`
`sum()`	求和	`sequenceOf(1,2,3).sum()`	`Int`
`count()`	元素个数	`sequence.count()`	`Int`
`first()` / `last()`	获取首/尾元素	`sequence.first()`	`T`
`forEach()`	遍历每个元素	`sequence.forEach { println(it) }`	`Unit`
`reduce()` / `fold()`	累加/聚合	`sequence.reduce { acc, e -> acc + e }`	`T`

三、完整示例：理解延迟执行与触发机制

fun main() {val result = sequenceOf(1, 2, 3, 4, 5).map {println("map $it")it * 2}.filter {println("filter $it")it > 5}.take(2) // 限制只取前两个符合条件的元素.toList() // 触发执行println("Result: $result")
}

序列与集合的处理方式对比

`Iterable`：急切（eager）执行

每个操作都在所有元素上执行，并产生中间集合。

val withIterator = (1..10).filter { print("Filter: $it, "); it % 2 == 0 }.map { print("Mapping: $it, "); it * 2 }.take(3)println()
// 输出：
// Filter: 1, Filter: 2, ... Filter: 10,
// Mapping: 2, Mapping: 4, Mapping: 6, Mapping: 8, Mapping: 10
// 结果：[4, 8, 12]

总共执行了：

10 次 filter
5 次 map
3 次 take
总计：18 次操作

`Sequence`：惰性（lazy）执行

每个元素在执行链中逐个被处理，没有中间集合。

val withSequence = (1..10).asSequence().filter { print("Filter: $it, "); it % 2 == 0 }.map { print("Mapping: $it, "); it * 2 }.take(3).toList()println()
// 输出：
// Filter: 1, Filter: 2, Mapping: 2, Filter: 3, Filter: 4, Mapping: 4, ...
// 结果：[4, 8, 12]