（一）迭代器的定义
迭代器是一种用于遍历集合元素的对象。它提供了统一的方式来访问各种集合类 型（如列表、映射、集合等）中的元素，而不需要了解集合的内部结构。
在 Scala 中，迭代器是一种抽象的概念，它有特定的接口和方法来实现元素的遍历。
（二）迭代器的基本使用
我们来看实际的需求。遍历输出List中的元素。
object lterator01 {
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){
println(it1.next()) // 3,4
}
}
}
(1) iterator方法创建对应的迭代器。这个迭代器可以用于遍历列表中的元素。
(2) hasNext方法检查是否还有下一个元素。
(3) next方法获取一个元素
（三）迭代器的优点
【对比foreach】它的优点在于：
(1) 内存效率高。迭代器采用延迟计算的方式，它不会将整个集合加载到内存中， 而是在每次调用next方法时才计算并返回下一个元素。
(2) 统一的遍历方法。迭代器为不同类型的集合（如列表、集合、映射等）提供了 一种统一的遍历方式。无论底层集合的具体结构如何，只要能获取到迭代器，就 可以使用相同的hasNext和next方法来遍历元素。
(3) 支持函数式编程风格，便于链式操作。
object iterator02 {
/*
* 迭代器 iterator
* 专门用来遍历（挨个访问）集合元素
* 1.获取。每个集合都有一个迭代器对象。用它来去遍历对象
* 2. 迭代器.next() 获取当前元素，移动迭代器
*
* Set， Map，List
*
* */
def main(args: Array[String]): Unit = {
val list1 = scala.collection.immutable.List(1,2,3,4,5)
// 访问这五个元素
// 1. 获取迭代器
val it: Iterator[Int] = list1.iterator
// 输出当前的元素
if(it.hasNext){
println("有下个元素 18")
}
println(it.next()) // 获取，移动
println(it.next())
println(it.next())
println(it.next())
println(it.next())
// println(it.next()) // 越界 NoSuchElementException
if(it.hasNext){
println("有下个元素")
}
// 2. 移动迭代器
// 3.输出当前的元素
}
}
（四）迭代器的常见方法
1. 子迭代器（以 drop 和 take 为例）*
我们可以使用drop和take方法创建子迭代器。drop方法会跳过指定数量的 元素，返回一个新的迭代器，而take方法会获取指定数量的元素作为一个新的迭代器。
object iterator03 {
/*
* 迭代器 iterator
* 专门用来遍历（挨个访问）集合元素
* 1.获取。每个集合都有一个迭代器对象。用它来去遍历对象
* 2. 迭代器.next() 获取当前元素，移动迭代器
*
* drop: 跳过指定个数的元素drop（3）
*
* take: 获取指定数量的元素
*
* */
def main(args: Array[String]): Unit = {
val list1 = scala.collection.immutable.List(1,2,3,4,5)
val it = list1.iterator
val it2 = it.take(2) // 从当前位置开始，只获取两个元素
while(it2.hasNext){
println(it2.next()) // 1,2
}
// val it2 = it.drop(1) // 跳过一个元素
//
// while(it2.hasNext){
// println(it2.next()) // 2,3,4,5
// }
}
}
2. duplicate 方法
功能：复制迭代器。返回一对迭代器，它们可以独立遍历原始迭代器中的元素序列。
语法：(迭代器1,迭代器2) = 迭代器.duplicate()
object iterator04 {
/*
* 迭代器 iterator
* 专门用来遍历（挨个访问）集合元素
* 1.获取。每个集合都有一个迭代器对象。用它来去遍历对象
* 2. 迭代器.next() 获取当前元素，移动迭代器
*
* drop: 跳过指定个数的元素drop（3）
*
* take: 获取指定数量的元素
*
* 迭代器是一次性的，next之后，就不能再回头
* duplicate: 复制迭代器
*
* */
def main(args: Array[String]): Unit = {
val list1 = scala.collection.immutable.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())
}
}
}
结果：
3
4
5
--------------
1
2
3
4
5
3. toList 方法*
toList方法将迭代器中的剩余元素转换为一个列表。这对于将迭代器中的数 据收 集起来或者在需要列表形式的数据时非常方便。
object iterator05 {
/*
* 迭代器 iterator
* 专门用来遍历（挨个访问）集合元素
* 1.获取。每个集合都有一个迭代器对象。用它来去遍历对象
* 2. 迭代器.next() 获取当前元素，移动迭代器
*
* drop: 跳过指定个数的元素drop（3）
*
* take: 获取指定数量的元素
*
* 迭代器是一次性的，next之后，就不能再回头
* duplicate: 复制迭代器
*
* toList 把迭代器中剩余的元素转入一个新的List中
*
* */
def main(args: Array[String]): Unit = {
val list1 = scala.collection.immutable.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
}
}
结果
3
List(4, 5)
4. zip 方法*
zip方法用于将两个迭代器的元素按顺序组合成一个新的迭代器，其中每个 元素是一个包含两个迭代器对应位置元素的元组。如果两个迭代器的长度不同， zip操作会在较短的迭代器耗尽时停止。
object iterator06 {
/*
* 迭代器 iterator
* 专门用来遍历（挨个访问）集合元素
* 1.获取。每个集合都有一个迭代器对象。用它来去遍历对象
* 2. 迭代器.next() 获取当前元素，移动迭代器
*
* drop: 跳过指定个数的元素drop（3）
*
* take: 获取指定数量的元素
*
* 迭代器是一次性的，next之后，就不能再回头
* duplicate: 复制迭代器
*
* toList 把迭代器中剩余的元素转入一个新的List中
*
* zip: 两个迭代器的元素按照顺序组合成一个新的迭代器。长度不一，会以短的为准
*
* */
def main(args: Array[String]): Unit = {
val it1 = scala.collection.immutable.List(1,2,3,4,5,6).iterator
val it2 = scala.collection.immutable.List("one","two","three","four","five").iterator
val it3 = it1.zip(it2)
while(it3.hasNext){
val pair = it3.next()
println(pair._1,pair._2)
}
}
}
结果
(1,one)
(2,two)
(3,three)
(4,four)
(5,five)
