（二十九）scala中的迭代器

（一）迭代器的定义

迭代器是一种用于遍历集合元素的对象。它提供了统一的方式来访问各种集合类 型（如列表、映射、集合等）中的元素，而不需要了解集合的内部结构。

在 Scala 中，迭代器是一种抽象的概念，它有特定的接口和方法来实现元素的遍历。

（二）迭代器的基本使用

我们来看实际的需求。遍历输出List中的元素

package iterator

object iterator01 {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5)
    // 如何依次输出这个5个元素？
    list.foreach(ele => println(ele))

    // 问: 如何只输出: 3,4
    val it = list.iterator.drop(2).take(2)
    while(it.hasNext){
      println(it.next())
    }
  }

}

1.  iterator方法创建对应的迭代器。这个迭代器可以用于遍历列表中的元素。

2. hasNext方法检查是否还有下一个元素。

3. next方法获取一个元素

（三）迭代器的优点

(1)内存效率高。迭代器采用延迟计算的方式，它不会将整个集合加载到内存中， 而是在每次调用next方法时才计算并返回下一个元素。

(2)统一的遍历方法。迭代器为不同类型的集合（如列表、集合、映射等）提供了 一种统一的遍历方式。无论底层集合的具体结构如何，只要能获取到迭代器，就 可以使用相同的hasNext和next方法来遍历元素。

(3)支持函数式编程风格，便于链式操作。

（四）迭代器的常见方法

1. next方法

package iterator

object iterator02 {
  /*
  * 1. next() 获取当前的元素，移动一次迭代器
  * 2. hasNext() 判断是否有下一个元素
  * 3. drop(n) 从当前位置开始，跳过n个元素，它返回一个新的迭代器
  */
  def main(args: Array[String]): Unit = {
    // 获取一个迭代器
    val it = List(1,2,3,4).iterator

    // println(it.next())
    // println(it.next())
    // println(it.next())
    // println(it.next())
    // println(it.next()) // NoSuchElementException: head of empty list

    val it1 = it.drop(2)

    while(it1.hasNext){
      println(it1.next()) // 3, 4
    }
  }
}

作用：获取迭代器的下一个元素，并将迭代器的位置向前移动一位。如果没 有下一个元素，调用next方法会抛出 NoSuchElementException异常。

2.  duplicate 方法

功能：复制迭代器。返回一对迭代器，它们可以独立遍历原始迭代器中的元素序列。

package iterator

object iterator02 {
  /*
  * 1. next() 获取当前的元素，移动一次迭代器
  * 2. hasNext() 判断是否有下一个元素
  * 3. drop(n) 从当前位置开始，跳过n个元素，它返回一个新的迭代器
  */
  def main(args: Array[String]): Unit = {
    // 获取一个迭代器
    val it = List(1,2,3,4,5,6,7,8,9,10).iterator

    // println(it.next())
    // println(it.next())
    // println(it.next())
    // println(it.next())
    // println(it.next()) // NoSuchElementException: head of empty list

    val (it1, it2) = it.duplicate
    // 使用it1访问前三个
    val it3 = it1.take(3)
    while(it3.hasNext){
      println(it3.next())
    }

    while(it1.hasNext){
      println(it1.next()) // 3, 4
    }
  }
}

3.  子迭代器（以 drop 和 take 为例）

我们可以使用drop和take方法创建子迭代器。drop方法会跳过指定数量的 元素，返回一个新的迭代器，而take方法会获取指定数量的元素作为一个新的迭 代器。

语法：(迭代器1,迭代器2) = 迭代器.duplicate()

package iterator

object iterator02 {
  /*
  * 1. next() 获取当前的元素，移动一次迭代器
  * 2. hasNext() 判断是否有下一个元素
  * 3. drop(n) 从当前位置开始，跳过n个元素，它返回一个新的迭代器
  */
  def main(args: Array[String]): Unit = {
    // 获取一个迭代器
    val it = List(1,2,3,4,5,6,7,8,9,10).iterator

    // println(it.next())
    // println(it.next())
    // println(it.next())
    // println(it.next())
    // println(it.next()) // NoSuchElementException: head of empty list

    val it1 = it.drop(5).take(4)

    while(it1.hasNext){
      println(it1.next()) // 3, 4
    }
  }
}

4. toList 方法

toList方法将迭代器中的剩余元素转换为一个列表。这对于将迭代器中的数 据收 集起来或者在需要列表形式的数据时非常方便。

5. zip 方法

zip方法用于将两个迭代器的元素按顺序组合成一个新的迭代器，其中每个 元素是一个包含两个迭代器对应位置元素的元组。如果两个迭代器的长度不同， zip操作会在较短的迭代器耗尽时停止。

package iterator
object iterator03 {
  /*
  * 1. next() 获取当前的元素，移动一次迭代器
  * 2. hasNext() 判断是否有下一个元素
  * 3. drop(n) 从当前位置开始，跳过n个元素，它返回一个新的迭代器
  * 4. take(n) 从当前位置开始，获取n个元素，它返回一个新的迭代器
  * 5. duplicate 复制迭代器
  * 6. zip(iter) 把两个迭代器对应位置的元素，组合成一个新的迭代器
  */
  def main(args: Array[String]): Unit = {
    val it = List(1,2,3,4,5).iterator
    // it.next()
    // it.next()
    // val list1 = it.toList
    // println(list1)

    val it1 = List(1,2,3,4,5,6).iterator
    val it2 = List("one", "two", "three", "four", "five").iterator
    val it3 = it1.zip(it2)
    while(it3.hasNext){
      val (r1, r2) = it3.next()
      println(s"${r1}, ${r2}")
    }
  }
}