kotlin sequenceOf 和 generateSequence 讲解

你想深入了解 Kotlin 中创建 Sequence（序列）的两个核心函数：sequenceOf 和 generateSequence，包括它们的区别、使用规则和实际案例，我会帮你理清这两个函数的适用场景和使用方式，让你能精准选择合适的函数创建序列。

一、核心概念先理清

首先明确：sequenceOf 和 generateSequence 都是 Kotlin 标准库提供的创建 Sequence 的顶层函数，但设计目标完全不同：

• sequenceOf：用于创建有限的、已知元素的序列（静态序列）；
• generateSequence：用于创建动态生成的序列（可无限、可按需生成，核心是惰性）。

二、sequenceOf 详解

1. 定义与规则
sequenceOf 是一个可变参数函数，接收一组确定的元素，直接封装成 Sequence。

• 语法：fun <T> sequenceOf(vararg elements: T): Sequence<T>
• 核心特点：元素是预先确定的，序列长度固定，本质是 “把已知元素包装成序列”。

2. 基础案例

fun main() {
    // 1. 基础使用：创建有限序列
    val numberSequence = sequenceOf(1, 2, 3, 4, 5)
    
    // 执行操作（惰性，直到终止操作触发）
    val result = numberSequence
        .filter { it % 2 == 0 }
        .map { it * 10 }
        .toList()
    
    println(result) // 输出：[20, 40]

    // 2. 空序列：sequenceOf() 或 emptySequence()
    val emptySeq1 = sequenceOf<Int>()
    val emptySeq2 = emptySequence<Int>()
    println(emptySeq1.count()) // 输出：0
    println(emptySeq2.count()) // 输出：0
}

3. 与 listOf 的对比
sequenceOf(1,2,3) 等价于 listOf(1,2,3).asSequence()，但 sequenceOf 更直接（无需先创建 List 再转换）：

fun main() {
    // 两种方式等价，但sequenceOf更简洁
    val seq1 = sequenceOf(1, 2, 3)
    val seq2 = listOf(1, 2, 3).asSequence()
    
    println(seq1.toList() == seq2.toList()) // 输出：true
}

三、generateSequence 详解

generateSequence 是创建动态序列的核心函数，它通过 “种子值 + 生成器函数” 按需生成元素，支持无限序列（惰性的核心体现）。
1. 两种重载形式

核心规则：

• 生成器函数返回 null 时，序列终止；
• 若生成器函数永远不返回 null，则生成无限序列；
• 元素是按需生成的（直到终止操作触发，才生成需要的元素）。

2. 案例 1：有种子的有限序列

fun main() {
    // 生成从1开始，每次+2，直到>10为止的序列
    val oddNumbers = generateSequence(1) { prev ->
        val next = prev + 2
        if (next > 10) null else next // 返回null终止序列
    }
    
    // 转换为List，触发元素生成
    println(oddNumbers.toList()) // 输出：[1, 3, 5, 7, 9]
}

3. 案例 2：无限序列（核心场景）
generateSequence 最强大的地方是支持无限序列（因为惰性，不会一次性生成所有元素）：

fun main() {
    // 生成无限自然数序列（1,2,3,...）
    val naturalNumbers = generateSequence(1) { it + 1 }
    
    // 只取前5个元素，不会生成全部无限元素
    val first5 = naturalNumbers.take(5).toList()
    println(first5) // 输出：[1, 2, 3, 4, 5]

    // 找第一个大于100的偶数（仅生成到102就终止）
    val firstEvenOver100 = naturalNumbers
        .filter { it % 2 == 0 }
        .first { it > 100 }
    println(firstEvenOver100) // 输出：102
}

4. 案例 3：无种子的序列（读取动态数据）
模拟 “逐行读取文件”（实际场景中，文件行是动态的、未知长度的）：

fun main() {
    // 模拟文件行生成器（实际可替换为File.reader().readLine()）
    var lineNumber = 0
    val fileLines = generateSequence {
        lineNumber++
        if (lineNumber > 3) null else "第${lineNumber}行内容"
    }
    
    // 遍历输出（按需生成每一行）
    fileLines.forEach { println(it) }
    // 输出：
    // 第1行内容
    // 第2行内容
    // 第3行内容
}

5. 案例 4：生成斐波那契数列

fun main() {
    // 种子是Pair(前一个数, 当前数)，初始为(0,1)
    val fibonacci = generateSequence(Pair(0, 1)) { (a, b) ->
        Pair(b, a + b) // 下一个数=前两个数之和
    }.map { it.second } // 提取数列值
    
    // 取前10个斐波那契数
    val first10Fib = fibonacci.take(10).toList()
    println(first10Fib) // 输出：[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
}

四、sequenceOf vs generateSequence 核心对比

五、避坑点

1. 无限序列必须加终止操作：
   若用 generateSequence 创建无限序列，必须搭配 take()、first() 等短路操作，否则调用 toList() 会导致无限循环 / 内存溢出：

// 错误示例（无限循环）：
// val allNatural = generateSequence(1) { it + 1 }.toList()

// 正确示例（加take限制）：
val limited = generateSequence(1) { it + 1 }.take(100).toList()

2. generateSequence 的种子可为 null：
   若种子为 null 且生成器函数也返回 null，则序列为空：

val emptySeq = generateSequence(null) { it ?: null }
println(emptySeq.count()) // 输出：0

总结

1. sequenceOf：用于创建已知元素的有限序列，是 “静态元素的序列包装器”，语法简洁，等价于 listOf(...).asSequence()。
2. generateSequence：用于创建动态生成的序列，支持无限序列和按需生成，核心是 “种子 + 生成器函数”，是处理动态 / 无限数据的首选。
3. 选择原则：元素已知用 sequenceOf，元素需要动态生成（如递推、读取动态数据）用 generateSequence。