Scala中迭代器

1.迭代器的定义

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

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

2.迭代器的基本使用

使用步骤：

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

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

(3) next方法获取一个元素

package iterator

object Iterator01 {
  def main(args: Array[String]): Unit = {

    val list1 = scala.collection.immutable.List(1,2,3,4,5)

//      list1.foreach(ele => {
//      println(ele)
//    })

    val it = list1.iterator
    val it1 = it.drop(2).take(2)
    while(it1.hasNext){  //3,4
      println(it1.next())
    }
  }
}

【总结】使用迭代器的基本步骤是：

• 第一步：构建一个迭代器

• 第二步：循环获取元素

3.迭代器的优点

对比foreach它的优点在于：

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

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

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

4.迭代器的常见方法

1.next方法：

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

package iterator

object Iterator02 {

  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问） 集合元素。
  *  1.获取。每一个集合都有一个迭代器对象，用它来遍历集合
  *  2.迭代器.next() 获取当前元素，移动迭代器
  *
  *
  *
  * Set, Map ,List
  *
 * */

  def main(args: Array[String]): Unit = {
    val list1 = List(1,2,3,4,5)

    // 访问这五个元素
//    1. 获取迭代器
    val it = list1.iterator
    // 输出当前的元素
//    val value = it.next() // 获取 ，移动

    println(it.next())
    println(it.next())
    println(it.next())
    println(it.next())
    println(it.next())
    // 返回的值为1,2,3,4,5 全部元素

//    println(value) // 越界（每返回一次，输出的元素往后移动一位，当我要输出全部元素时，只需要写五次）

  }

}

2.drop和take方法：

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

package iterator

object Iterator03 {

  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问） 集合元素。
  *  1.获取。每一个集合都有一个迭代器对象，用它来遍历集合
  *  2.迭代器.next() 获取当前元素，移动迭代器
  *
  * dorp：跳过指定个数的元素drop(3)
  *
  * take: 获取指定数量的元素
  *
 * */

  def main(args: Array[String]): Unit = {
     val list1 = List(1,2,3,4,5)

    val it = list1.iterator

    val it2 = it.take(3) // 从当前位置开始，只获取三个元素

    while(it2.hasNext){
      println(it2.next())
    }

//    val it2 = it.drop(1) // 跳过一个元素
//
//    while(it2.hasNext){
//      println(it2.next())
//    }
  }
}

3.duplicate方法

功能：复制迭代器。返回一对迭代器，它们可以独立遍历原始迭代器中的元素序列。 语法：(迭代器1,迭代器2) = 迭代器.duplicate()

场景：需要多次遍历同一个集合，但又不想重新创建迭代器或者影响原迭代器状 态的情况下非常有用。

【举例】：有一个迭代器包含了一系列的数值，你想要将这些数值分为两组，一组用 于计算平均值，另一组用于与平均值进行比较

package iterator

object Iterator04 {

  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问） 集合元素。
  *  1.获取。每一个集合都有一个迭代器对象，用它来遍历集合
  *  2.迭代器.next() 获取当前元素，移动迭代器
  *
  * 迭代器是一次性的，next之后，就不能再回头
  * duplicate：复制迭代器
  *
 * */

  def main(args: Array[String]): Unit = {
     val list1 = List(1,2,3,4,5)

    val it = list1.iterator

    val (it1,it2) = it.duplicate

    it.next() // 一次性
    it.next()
    while(it1.hasNext){
      println(it1.next())
    }
    println("--------------")
    while(it2.hasNext){
      println(it2.next())
    }
  }
}

4.toList方法

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

package iterator

object Iterator05 {

  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问） 集合元素。
  *  1.获取。每一个集合都有一个迭代器对象，用它来遍历集合
  *  2.迭代器.next() 获取当前元素，移动迭代器
  *
  * 迭代器是一次性的，next之后，就不能再回头
  * duplicate：复制迭代器
  *
  * toList:把迭代器中剩余的元素转入一个新的list中
 * */

  def main(args: Array[String]): Unit = {
     val list1 = List(1,2,3,4,5)

    val it = list1.iterator
    it.next()
    it.next()

    println(it.next()) // 3
    // 希望把剩余的内容，装入一个新的List
    val newList = it.toList
    println(newList)


  }
}

5.zip方法

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

package iterator

object Iterator06 {

  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问） 集合元素。
  *  1.获取。每一个集合都有一个迭代器对象，用它来遍历集合
  *  2.迭代器.next() 获取当前元素，移动迭代器
  *
  * zip:两个迭代器的元素按照顺序组合成一个新的迭代器，长度不一，会以短的为准
  *
 * */

  def main(args: Array[String]): Unit = {
    val it1 = List(1,2,3,4,5).iterator
    val it2 = List("one","two","three","four","five").iterator

    val it3 = it1.zip(it2)

    while(it3.hasNext){
      val pair = it3.next()
      println(pair._1,pair._2)
    }

  }
}