迭代器

迭代器不是集合，而是一种逐个访问集合元素的方法。迭代器 it 上的两个基本操作是 next 和 hasNext。调用 it.next() 将返回迭代器的下一个元素并推进迭代器状态。再次对同一迭代器调用 next 将产生比之前返回的元素多一个的元素。如果没有更多元素要返回，调用 next 将抛出 NoSuchElementException。可以使用 Iterator 的 hasNext 方法来了解是否有更多元素要返回。

“遍历”迭代器 it 返回的所有元素的最直接方法是使用 while 循环

while (it.hasNext)
  println(it.next())

while it.hasNext do
  println(it.next())

Scala 中的迭代器还提供了 Iterable 和 Seq 类中大多数方法的类似方法。例如，它们提供了一个 foreach 方法，该方法对迭代器返回的每个元素执行给定的过程。使用 foreach，上面的循环可以缩写为

it.foreach(println)

与往常一样，for 表达式可以用作涉及 foreach、map、withFilter 和 flatMap 的表达式的备用语法，因此打印迭代器返回的所有元素的另一种方法是

for (elem <- it) println(elem)

for elem <- it do println(elem)

迭代器上的 foreach 方法和可迭代集合上的相同方法之间有一个重要的区别：当在迭代器上调用时，foreach 在完成时会将迭代器保留在其末尾。因此，再次对同一个迭代器调用 next 将失败，并出现 NoSuchElementException。相比之下，当在集合上调用时，foreach 保留集合中的元素数量不变（除非传递的函数添加或删除元素，但这不推荐，因为它可能会导致意外结果）。

其他 Iterator 与 Iterable 共有的操作具有相同的属性。例如，迭代器提供了一个 map 方法，该方法返回一个新迭代器

scala> val it = Iterator("a", "number", "of", "words")
val it: Iterator[java.lang.String] = <iterator>

scala> it.map(_.length)
val res1: Iterator[Int] = <iterator>

scala> it.hasNext
val res2: Boolean = true

scala> res1.foreach(println)
1
6
2
5

scala> it.hasNext
val res4: Boolean = false

如你所见，在调用 it.map 之后，it 迭代器尚未推进到其末尾，但是遍历由调用 res1.foreach 产生的迭代器也会遍历 it 并将其推进到其末尾。

另一个示例是 dropWhile 方法，该方法可用于查找具有特定属性的迭代器的第一个元素。例如，要查找上面迭代器中至少有两个字符的第一个单词，你可以编写

scala> val it = Iterator("a", "number", "of", "words")
val it: Iterator[java.lang.String] = <iterator>

scala> it.dropWhile(_.length < 2)
val res4: Iterator[java.lang.String] = <iterator>

scala> res4.next()
val res5: java.lang.String = number

再次注意，it 已被调用 dropWhile 更改：它现在指向列表中的第二个单词“number”。事实上，it 和 dropWhile 返回的结果 res4 将返回完全相同的元素序列。

规避此行为的一种方法是duplicate底层迭代器，而不是直接调用其上的方法。产生的两个迭代器将分别返回与底层迭代器it完全相同的元素

scala> val (words, ns) = Iterator("a", "number", "of", "words").duplicate
val words: Iterator[String] = <iterator>
val ns: Iterator[String] = <iterator>

scala> val shorts = words.filter(_.length < 3).toList
val shorts: List[String] = List(a, of)

scala> val count = ns.map(_.length).sum
val count: Int = 14

这两个迭代器独立工作：推进一个不会影响另一个，因此可以通过调用任意方法来破坏性地修改每个迭代器。这造成了两次迭代元素的错觉，但效果是通过内部缓冲实现的。与往常一样，底层迭代器it不能直接使用，必须丢弃。

总之，如果在调用迭代器上的方法后不再访问该迭代器，则迭代器表现得像集合一样。Scala 集合库通过抽象IterableOnce明确表示这一点，它是Iterable和Iterator的公共超类。IterableOnce[A]只有两个方法：iterator: Iterator[A]和knownSize: Int。如果IterableOnce对象实际上是Iterator，则其iterator操作始终返回自身，处于当前状态，但如果它是Iterable，则其iterator操作始终返回一个新的Iterator。IterableOnce的一个常见用例是作为可以将迭代器或集合作为参数的方法的参数类型。一个示例是类Iterable中的追加方法concat。它采用IterableOnce参数，因此你可以追加来自迭代器或集合的元素。

下面总结了对迭代器的所有操作。

Iterator 类中的操作

惰性

与直接对具体集合（如 List）执行的操作不同，对 Iterator 执行的操作是惰性的。

惰性操作不会立即计算其所有结果。相反，它在单独请求结果时计算结果。

因此，表达式 (1 to 10).iterator.map(println) 不会在屏幕上打印任何内容。在这种情况下，map 方法不会将其参数函数应用于范围中的值，它返回一个新的 Iterator，该 Iterator 会在请求每个值时执行此操作。将 .toList 添加到该表达式的末尾实际上会打印元素。

由此产生的一个后果是，map 或 filter 等方法不一定将其参数函数应用于所有输入元素。例如，表达式 (1 to 10).iterator.map(println).take(5).toList 仅会打印值 1 到 5，因为这些值是仅从 map 返回的 Iterator 请求的值。

这就是仅将纯函数用作 map、filter、fold 和类似方法的参数非常重要的原因之一。请记住，纯函数没有副作用，因此通常不会在 map 中使用 println。 println 用于演示惰性，因为通常在纯函数中看不到惰性。

尽管懒惰通常不可见，但它仍然很有价值，因为它可以防止不必要的计算发生，并且可以处理无限序列，如下所示

def zipWithIndex[A](i: Iterator[A]): Iterator[(Int, A)] =
  Iterator.from(0).zip(i)

缓冲迭代器

有时，您需要一个可以“向前看”的迭代器，以便在不超越该元素的情况下检查要返回的下一个元素。例如，考虑从返回字符串序列的迭代器中跳过前导空字符串的任务。您可能很想编写以下内容

def skipEmptyWordsNOT(it: Iterator[String]) =
  while (it.next().isEmpty) {}

def skipEmptyWordsNOT(it: Iterator[String]) =
  while it.next().isEmpty do ()

但是仔细查看此代码，很明显这是错误的：该代码确实会跳过前导空字符串，但它也会推进 it 超过第一个非空字符串！

def skipEmptyWords(it: BufferedIterator[String]) =
  while (it.head.isEmpty) { it.next() }

def skipEmptyWords(it: BufferedIterator[String]) =
  while it.head.isEmpty do it.next()

scala> val it = Iterator(1, 2, 3, 4)
val it: Iterator[Int] = <iterator>

scala> val bit = it.buffered
val bit: scala.collection.BufferedIterator[Int] = <iterator>

scala> bit.head
val res10: Int = 1

scala> bit.next()
val res11: Int = 1

scala> bit.next()
val res12: Int = 2

scala> bit.headOption
val res13: Option[Int] = Some(3)

scala> def collapse(it: Iterator[Int]) = if (!it.hasNext) Iterator.empty else {
      |  var head = it.next
      |  val rest = if (head == 0) it.dropWhile(_ == 0) else it
      |  Iterator.single(head) ++ rest
      |}
def collapse(it: Iterator[Int]): Iterator[Int]

scala> def collapse(it: Iterator[Int]) = {
      |  val (zeros, rest) = it.span(_ == 0)
      |  zeros.take(1) ++ rest
      |}
def collapse(it: Iterator[Int]): Iterator[Int]

scala> collapse(Iterator(0, 0, 0, 1, 2, 3, 4)).toList
val res14: List[Int] = List(0, 1, 2, 3, 4)

scala> def collapse(it: Iterator[Int]) = if !it.hasNext then Iterator.empty else
      |  var head = it.next
      |  val rest = if head == 0 then it.dropWhile(_ == 0) else it
      |  Iterator.single(head) ++ rest
      |
def collapse(it: Iterator[Int]): Iterator[Int]

scala> def collapse(it: Iterator[Int]) =
      |  val (zeros, rest) = it.span(_ == 0)
      |  zeros.take(1) ++ rest
      |
def collapse(it: Iterator[Int]): Iterator[Int]

scala> collapse(Iterator(0, 0, 0, 1, 2, 3, 4)).toList
val res14: List[Int] = List(0, 1, 2, 3, 4)