Scala-迭代器

定义

迭代器不是一种集合，它是一种用于访问集合的方法。

需要通过集合对应的迭代器调用迭代器的方法来访问。

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

练习迭代器的使用:

object Test_迭代 {
  def main(args: Array[String]): Unit = {
    val list1 =List(1,2,3,4)
    //1. foreach 实现
    list1.foreach(println)

    //2.迭代器
    //2.1构建迭代器
    val it = list1.iterator
    //2.2依次取元素
    while (it.hasNext){
      println(it.next())
    }

    val set1 =Set("apple","banana")
    val it2 =set1.iterator //构建迭代器
    while (it2.hasNext){
      println(it2.next())
    }
    it2.map(a => s"I like $a").foreach(println)
  }
}

object Test_迭代 {
  def main(args: Array[String]): Unit = {
    val list1 =List(1,2,3,4)
 //duplicate:复制迭代器
    //得到一组，两个迭代器，它们有相同的数据，但是相互独立
    val it = List(3,4,5,6,7).iterator

    val (it1,it2) = it.duplicate
    println(it1,it2)

    //用第一个迭代器 来计算平均值
    val dataList = it1.toList//把迭代器的数据放到列表中
    val avg = dataList.sum / dataList.size
    println("平均值："+avg)

    //用第二个迭代器来选出大于平均值的元素
    it2.filter(x => x > avg).foreach(println)
    }
}

 take:从当前位置开始，取几个元素，得到新的迭代器

  drop：从当前位置开始，跳过指定数量的元素，得到新的迭代器

    //take:从当前位置开始，取几个元素，得到新的迭代器
    val it = List(1,2,3,4,5,6,7).iterator

    //drop：从当前位置开始，跳过指定数量的元素，得到新的迭代器
    val it2 = it.drop(3)
    //只输出3个
    val it1 = it2.take(3)

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

toList的作用：把迭代器中剩余的元素保存到一个List中

 //toList的作用：把迭代器中剩余的元素保存到一个List中
    val it = List(1,2,3,4,5,6,7).iterator
    it.next()//移动一次
    it.next()//移动一次
    while (it.hasNext){
            println(it.next())
    }
    val li = it.toList
    println(li)

zip方法（拉链）：把两个迭代器合成一下，得到新的迭代器，长度以短的为准

    val nums = List(1,2,3).iterator
    val words = List("one","two","three").iterator

    //zip:把两个迭代器合成一下，得到新的迭代器，长度以短的为准
    val it = nums.zip(words)

    while (it.hasNext){
      val p = it.next()//元组
      println(s"${p._1} ===== ${p._2}")
    }

【课后小答】

1.以下关于送代器next为法说法正确的是（C）
A.它总是返回送代器中的第一个元条。
B.它返回送代器中的下一个无善，并将送代器位置向前移动一位，如果没有下一个元素会返回None。
C.它返回送代器中的下一个元素，并将送代器位置向前移动一位，如果没有下一个元素会抛出NoSuchElementException.
D.它可以返回送代器中的任意一个元素。

2.duplicate方法创建的法代器副本与原送化器（A）
A.共享元素序列，修改典中一个会彩响另一个。
B.不共享元素序列，修改共一一个不会影响另一个。
C.共享元素序列，但修故热中一个不会影响另一个。
D.没有任何关系

3.对于ziP方法，当两个选代器台度不同时（B)
A.会自动补齐较短的送优器，使英长度与较长的送代器相同。
B.会在较短的送代器耗尽时停上zip操作。
C.会抛出异常。
D.会重复使用较短的送代器元素，直到与较长的送代器长度相同。

4.toList方法对迭代器的作用是(B)
A.将迭代器中的所有元素转换为一个列表，包括已经遍历过的元素。
B.将迭代器中的剩余元素转换为一个列表。
C.将列表转换为迭代器。
D.将选代器转换为一个不可变的集合。

5.使用drop方法创建的子送代器（B）
A.包含原迭代器的所有元素。
B.从原迭代器的开头开始，跳过指定数量的元素后包含剩余的元素。
C.包含原选代器中指定数量的元素，从开头开始。
D.是原迭代器的一个副本，不跳过任何元素

【实训】

1.创建学生信息数据结构和初始数据。创建一个表示学生信息的类，case
sludenl包含姓名、年龄和成绩列表[数学，英语，语文7等属性。然后创建几个学生
对象，并将它们存储在一个列表中
2.创建迭代器并进行基础遍历。为学生列表创建选代器，使用选代器的hasNext
和nexL方法遍历学生信息，打印每个学生的姓名。
3.使用duplicate方法和筛选操作。利用duplicate方法创建送代器副本。在
原迭代器上根据年龄条件筛洗年龄>20岁的同学，在副本迭代器上根据语文成绩条件
筛选＞80分的同学。
4.使用zip方法关联信息。创建一个新的列表用于存储每个学生的平均成绩(E
门课的平均成绩)，再创建该列表的选代器。通过ZID方法将学生法代器和平均成绩
迭代器组合，然后打印每个学生的姓名和平均成绩。
5.打印前三名的同学信息。
6.打印从第4名开始的后3位同学的信息。
7.重新创建学生列表的迭代器，用于统计所有学生的所有成绩的总和，并打印结
果
8.再次使用该迭代器，筛选出成绩列表中有至少一个特定分数以上的学生信息,
并打印他们的姓名和年龄。

// 1. 创建学生信息数据结构和初始数据
case class Student(name: String, age: Int, scores: List[Double])

object StudentOperations {
    def main(args: Array[String]) {
        // 创建几个学生对象，并将它们存储在一个列表中
        val student1 = Student("张三", 18, List(85.0, 90.0, 80.0))
        val student2 = Student("李四", 22, List(75.0, 85.0, 90.0))
        val student3 = Student("王五", 20, List(90.0, 80.0, 75.0))
        val student4 = Student("赵六", 25, List(88.0, 92.0, 85.0))
        val studentList = List(student1, student2, student3, student4)

        // 2. 创建迭代器并进行基础遍历
        val studentIterator = studentList.iterator
        while (studentIterator.hasNext) {
            val student = studentIterator.next()
            println(s"学生姓名: ${student.name}")
        }

        // 3. 使用duplicate方法和筛选操作
        val (originalIterator, duplicateIterator) = studentList.iterator.duplicate
        val filteredByAge = originalIterator.filter(_.age > 20)
        val filteredByChineseScore = duplicateIterator.filter(_.scores(2) > 80)

        println("年龄大于20岁的同学:")
        filteredByAge.foreach(student => println(student.name))

        println("语文成绩大于80分的同学:")
        filteredByChineseScore.foreach(student => println(student.name))

        // 4. 使用zip方法关联信息
        val averageScoresList = studentList.map(student => student.scores.sum / student.scores.length)
        val averageScoresIterator = averageScoresList.iterator

        val zippedIterator = studentList.iterator.zip(averageScoresIterator)
        println("学生姓名和平均成绩:")
        zippedIterator.foreach { case (student, averageScore) =>
            println(s"${student.name} 的平均成绩: $averageScore")
        }

        // 5. 打印前三名的同学信息
        println("前三名同学信息:")
        studentList.take(3).foreach(println)

        // 6. 打印从第4名开始的后3位同学的信息
        println("从第4名开始的后3位同学信息:")
        studentList.drop(3).take(3).foreach(println)

        // 7. 重新创建学生列表的迭代器，用于统计所有学生的所有成绩的总和，并打印结果
        val allScoresIterator = studentList.iterator
        var totalScore = 0.0
        while (allScoresIterator.hasNext) {
            val student = allScoresIterator.next()
            totalScore += student.scores.sum
        }
        println(s"所有学生的所有成绩总和: $totalScore")

        // 8. 再次使用该迭代器，筛选出成绩列表中有至少一个特定分数以上的学生信息，并打印他们的姓名和年龄
        val specificScore = 85.0
        val filteredBySpecificScore = studentList.iterator.filter(student => student.scores.exists(_ > specificScore))
        println(s"成绩中有至少一个大于 $specificScore 分的同学信息:")
        filteredBySpecificScore.foreach(student => println(s"姓名: ${student.name}, 年龄: ${student.age}"))
    }
}