Kotlin序列（Sequences）[编辑 | 编辑源代码]

Kotlin序列（Sequences）是一种惰性集合操作的数据结构，允许高效处理大型数据集或无限数据流。与标准集合（如List或Set）不同，序列仅在需要时计算元素，避免中间结果的临时存储，从而提升性能。本节将详细介绍序列的特性、创建方式、操作及实际应用场景。

概述[编辑 | 编辑源代码]

序列（Sequence<T>）是Kotlin标准库中的接口，代表按顺序排列的元素集合。其核心特点是：

惰性求值：操作（如`map`、`filter`）不会立即执行，而是在终端操作（如`toList()`）触发时按需计算。
管道化：多个操作按顺序逐个应用于每个元素，而非像集合那样生成中间结果。
无限可能性：可表示无限数据流（如斐波那契数列）。

序列适用于：

大数据集处理（减少内存占用）
复杂操作链（避免中间集合创建）
延迟计算（如读取文件流）

创建序列[编辑 | 编辑源代码]

Kotlin提供多种方式创建序列：

使用`sequenceOf()`[编辑 | 编辑源代码]

直接声明已知元素的序列：

val numbers = sequenceOf(1, 2, 3, 4, 5)
println(numbers.toList()) // 输出: [1, 2, 3, 4, 5]

使用`asSequence()`[编辑 | 编辑源代码]

将现有集合转换为序列：

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

使用生成器函数[编辑 | 编辑源代码]

通过`generateSequence`创建无限或有限序列：

// 无限序列（需限制操作）
val infiniteSeq = generateSequence(0) { it + 1 }
println(infiniteSeq.take(5).toList()) // 输出: [0, 1, 2, 3, 4]

// 有限序列（以null终止）
val finiteSeq = generateSequence(1) { if (it < 5) it + 1 else null }
println(finiteSeq.toList()) // 输出: [1, 2, 3, 4, 5]

使用`sequence {}`构建器[编辑 | 编辑源代码]

通过yield函数逐步生成元素：

val fibSeq = sequence {
    var a = 0
    var b = 1
    yield(a)
    yield(b)
    while (true) {
        val next = a + b
        yield(next)
        a = b
        b = next
    }
}
println(fibSeq.take(7).toList()) // 输出: [0, 1, 1, 2, 3, 5, 8]

序列操作[编辑 | 编辑源代码]

序列操作分为两类：中间操作（返回新序列）和终端操作（返回具体结果）。

中间操作[编辑 | 编辑源代码]

`filter`：筛选符合条件的元素
`map`：转换元素
`take`：获取前N个元素
`drop`：跳过前N个元素

val result = sequenceOf(1, 2, 3, 4, 5)
    .filter { it % 2 == 0 }  // 中间操作
    .map { it * 2 }          // 中间操作
    .toList()                // 终端操作
println(result) // 输出: [4, 8]

终端操作[编辑 | 编辑源代码]

`toList()`：转换为列表
`first()`：获取第一个元素
`count()`：统计元素数量
`sum()`：计算总和

序列 vs 集合[编辑 | 编辑源代码]

通过对比理解序列的惰性特性：

操作步骤对比（处理1万元素的集合）
方式	操作步骤	内存使用
1. 创建初始集合 2. 创建过滤后的新集合 3. 创建映射后的新集合 \| 3个临时集合
1. 创建序列 2. 按需逐个处理元素 \| 仅存储当前元素

示例代码对比：

// 集合处理（急求值）
val listResult = (1..1_000_000).toList()
    .filter { it % 2 == 0 }  // 创建中间集合
    .map { it * 2 }          // 创建另一个中间集合
    .take(10)                // 最终只取10个元素
    .toList()

// 序列处理（惰性求值）
val seqResult = (1..1_000_000).asSequence()
    .filter { it % 2 == 0 }  // 逐个元素过滤
    .map { it * 2 }          // 逐个元素映射
    .take(10)                // 取前10个后停止
    .toList()                // 触发实际计算

性能优化案例[编辑 | 编辑源代码]

场景：从大型日志文件中查找前10条包含"ERROR"的行并提取错误码。

传统方式（集合）[编辑 | 编辑源代码]

// 可能内存不足！
val lines = File("huge.log").readLines()  // 读取所有行到内存
val errors = lines.filter { "ERROR" in it }
    .map { it.substring(5, 9) }          // 提取错误码
    .take(10)

序列优化[编辑 | 编辑源代码]

val errorCodes = File("huge.log").useLines { lines ->
    lines.asSequence()                    // 按行惰性处理
        .filter { "ERROR" in it }
        .map { it.substring(5, 9) }
        .take(10)
        .toList()                        // 仅收集最终结果
}

无限序列应用[编辑 | 编辑源代码]

生成无限斐波那契数列并获取特定值：

fun fibonacci(): Sequence<Int> = sequence {
    var terms = Pair(0, 1)
    while (true) {
        yield(terms.first)
        terms = Pair(terms.second, terms.first + terms.second)
    }
}

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

// 检查第5项是否为3（从0开始）
println(fibonacci().elementAt(4) == 3) // 输出: true