scala中的迭代器

迭代器(Iterator)的定义

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

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

基本代码

/*
*List(1,2,3,4,5)
*
 */


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

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

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

    //跳过list的前两个元素，而输出随后的两个元素
    val it=list1.iterator
    val it1=it.drop(2).take(2)
    while(it1.hasNext){ // 3 4
      println(it1.next())
    }

  }
}

访问元素的基本代码

package iterator

object iterator02 {
  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问）集合元素。
  *   1. 获取。每个集合都有一个迭代器对象。用它去遍历集合
  *   2. 迭代器.next()  获取当前元素，移动迭代器
  *
  *
   */
  def main(args: Array[String]): Unit = {
    val list1=List(1,2,3,4,5)

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

    //println(it.next()) //越界 java.util.NoSuchElementException: head of empty list
    //2. 移动迭代器
    //3. 输出当前的元素
  }
}

drop和take

drop：跳过制定个数的元素

take：获取制定数量的元素

基本代码

package iterator

object iterator03 {
  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问）集合元素。
  *   1. 获取。每个集合都有一个迭代器对象。用它去遍历集合
  *   2. 迭代器.next()  获取当前元素，移动迭代器
  *
  *   drop：跳过制定个数的元素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())
//    }
  }
}

duplicate

复制迭代器。迭代器是一次性的，next之后，就不能再回头。

基本代码

object iterator04 {
  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问）集合元素。
  *   1. 获取。每个集合都有一个迭代器对象。用它去遍历集合
  *   2. 迭代器.next()  获取当前元素，移动迭代器
  *
  *   drop：跳过制定个数的元素drop(3)
  *
  *   take：获取制定数量的元素
  *
  *   迭代器是一次性的，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

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

toList

把迭代器中剩余的元素转入一个新的list中。

基本代码

object iterator05 {
  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问）集合元素。
  *   1. 获取。每个集合都有一个迭代器对象。用它去遍历集合
  *   2. 迭代器.next()  获取当前元素，移动迭代器
  *
  *   drop：跳过制定个数的元素drop(3)
  *
  *   take：获取制定数量的元素
  *
  *   迭代器是一次性的，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)  // 4 5
  }
}

zip

两个迭代器的元素按照顺序组合成一个新的迭代器。长度不一，会以短的为准。

基本代码

object iterator06 {
  /*
  * 迭代器 Iterator
  * 专门用来遍历（挨个访问）集合元素。
  *   1. 获取。每个集合都有一个迭代器对象。用它去遍历集合
  *   2. 迭代器.next()  获取当前元素，移动迭代器
  *
  *   drop：跳过制定个数的元素drop(3)
  *
  *   take：获取制定数量的元素
  *
  *   迭代器是一次性的，next之后，就不能再回头
  *   duplicate：复制迭代器
  *
  *   toList 把迭代器中剩余的元素转入一个新的list中。
  * 
  *   zip：两个迭代器的元素按照顺序组合成一个新的迭代器。长度不一，会以短的为准。
   */
  def main(args: Array[String]): Unit = {
    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 pair=it3.next()
      println(pair._1,pair._2)
    }

  }
}