编辑“︁Kotlin迭代器”︁（章节）

= Kotlin迭代器 =

'''迭代器（Iterator）'''是Kotlin中用于遍历集合（如列表、集合、映射等）元素的一种机制。它提供了一种统一的方式来访问集合中的元素，而无需关心底层集合的具体实现。迭代器是Kotlin标准库的一部分，支持对集合的顺序访问和修改（如果集合是可变的）。

== 迭代器基础 ==

Kotlin中的迭代器遵循以下核心原则：
* 通过{{mono|iterator()}}函数获取迭代器实例
* 使用{{mono|hasNext()}}检查是否还有元素可遍历
* 使用{{mono|next()}}获取下一个元素
* 可变迭代器（{{mono|MutableIterator}}）还支持{{mono|remove()}}操作

=== 基本迭代器示例 ===
以下代码展示如何使用迭代器遍历一个列表：

<syntaxhighlight lang="kotlin">
fun main() {
    val numbers = listOf("one", "two", "three", "four")
    val iterator = numbers.iterator()
    
    while (iterator.hasNext()) {
        println(iterator.next())
    }
}
</syntaxhighlight>

'''输出：'''
<pre>
one
two
three
four
</pre>

== 迭代器类型 ==

Kotlin提供了几种迭代器变体：

=== ListIterator ===
专为列表设计的迭代器，支持双向遍历：

<syntaxhighlight lang="kotlin">
fun main() {
    val numbers = listOf("one", "two", "three")
    val listIterator = numbers.listIterator()
    
    // 正向遍历
    while (listIterator.hasNext()) {
        println("正向: ${listIterator.next()}")
    }
    
    // 反向遍历
    while (listIterator.hasPrevious()) {
        println("反向: ${listIterator.previous()}")
    }
}
</syntaxhighlight>

=== MutableIterator ===
允许在遍历时修改集合：

<syntaxhighlight lang="kotlin">
fun main() {
    val mutableNumbers = mutableListOf(1, 2, 3, 4)
    val mutableIterator = mutableNumbers.iterator()
    
    while (mutableIterator.hasNext()) {
        val item = mutableIterator.next()
        if (item % 2 == 0) {
            mutableIterator.remove() // 删除偶数
        }
    }
    
    println(mutableNumbers) // 输出: [1, 3]
}
</syntaxhighlight>

== 迭代器的工作原理 ==

迭代器内部维护一个"游标"来跟踪当前位置：

<mermaid>
stateDiagram-v2
    [*] --> 开始
    开始 --> 有元素: hasNext() = true
    有元素 --> 获取元素: next()
    获取元素 --> 有元素
    有元素 --> 结束: hasNext() = false
    结束 --> [*]
</mermaid>

数学上，迭代器可以表示为：
<math>
I = (C, p, f_{next}, f_{hasNext})
</math>
其中：
* <math>C</math> 是集合
* <math>p</math> 是当前位置指针
* <math>f_{next}</math> 是获取下一个元素的函数
* <math>f_{hasNext}</math> 是检查是否有下一个元素的函数

== 实际应用案例 ==

=== 案例1：文件行处理 ===
迭代器非常适合处理大文件，可以逐行读取而不必加载整个文件到内存：

<syntaxhighlight lang="kotlin">
import java.io.File

fun processLargeFile(filename: String) {
    File(filename).useLines { lines ->
        val lineIterator = lines.iterator()
        while (lineIterator.hasNext()) {
            processLine(lineIterator.next())
        }
    }
}

fun processLine(line: String) {
    // 处理每一行的逻辑
    println(line.trim())
}
</syntaxhighlight>

=== 案例2：自定义迭代器 ===
实现一个斐波那契数列迭代器：

<syntaxhighlight lang="kotlin">
class FibonacciIterator : Iterator<Int> {
    private var a = 0
    private var b = 1
    
    override fun hasNext() = true // 无限序列
    
    override fun next(): Int {
        val result = a
        a = b
        b += result
        return result
    }
}

fun main() {
    val fib = FibonacciIterator()
    repeat(10) {
        println(fib.next())
    }
}
</syntaxhighlight>

'''输出：'''
<pre>
0
1
1
2
3
5
8
13
21
34
</pre>

== 迭代器的限制 ==

* '''一次性'''：大多数迭代器只能遍历一次，再次遍历需要获取新的迭代器
* '''单向性'''：普通迭代器只能向前移动（ListIterator除外）
* '''并发修改'''：在迭代过程中修改集合（非通过迭代器自身）会导致{{mono|ConcurrentModificationException}}

== 最佳实践 ==

1. 优先使用Kotlin的{{mono|for}}循环，它内部使用迭代器但语法更简洁
2. 处理大集合时考虑使用序列（Sequence）和迭代器组合
3. 需要并行处理时考虑使用并发集合和对应的安全迭代器
4. 实现自定义集合时，确保提供正确的迭代器实现

== 扩展知识 ==

Kotlin还提供了{{mono|forEachRemaining()}}方法，可以对剩余所有元素执行操作：

<syntaxhighlight lang="kotlin">
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val iterator = numbers.iterator()
    
    // 跳过前两个元素
    iterator.next()
    iterator.next()
    
    // 处理剩余元素
    iterator.forEachRemaining { println(it * 2) }
}
</syntaxhighlight>

'''输出：'''
<pre>
6
8
10
</pre>

{{Tip|在Kotlin中，大多数情况下你不需要直接使用迭代器，因为语言提供了更高级的构造如{{mono|for}}循环和集合操作函数。但在某些特定场景下，直接使用迭代器能提供更好的控制。}}

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin控制流]]