1.迭代器定义
Scala Ierator (选代器)不是一个集合,它是一种用于访问集合的方法。如果要访问集合,需要通过集合对应的迭代器调用迭代器的方法来访问。另外,还可以利用集合本身提供的方法访问集合。
2.迭代器使用
在Scala中利用选代器访问集合的方法与Java中相同。假如需要遍历集合Set,则需要先遍历集合对应的迭代器。判断迭代器中是否还存在下一个元素,如果存在便会取出这个元素。迭代器使用格式如下:
while (it.hasNext)
println(it.next())
迭代器的例子
object Test {
def main(args: Array[String]): Unit = {
val list1 =List(1,2,3,4,5)
//任务:输出每一个元素
// list1.foreach(println)
//任务:跳过前面两个,从第三个开始输出
//迭代器
//1.创建一个迭代器(iterator)
val it1 =list1.iterator
println(it1.next())
val it2 =it1.drop(2)
//2.依次访问每个元素
//hasNext()是否有下一个
// next(): 得到当前元素,并把迭代器向后移动一个位置
while (it2.hasNext){
println(it2.next())
}
println(it2.hasNext)
val list2=List(1,2,3)
val it3=list2.iterator
it3.next()
it3.next()
it3.next()
// it3.next()//没有这个元素,迭代器移过头了!!!
//
val m1 =Map("11"->1,"22"->2)
val s1=Set("A","B","C")
val it4=s1.iterator
while (it4.hasNext) {
println(it4.next())
}
println(("-"*20))
//任务是:打印前三个
val list4=List(1,2,3,4,5,6,7)
val it5=list4.iterator
//take:从当前的迭代器的位置开始,取n个元素
val it6=it5.take(3)
while(it6.hasNext){
println(it6.next())
}
//只输出4,5,6 跳过前三个,再取三个
val it7=list4.iterator.drop(3).take(3)
//drop 起点 take 终点
while (it7.hasNext){
println(it7.next())
}
//复制迭代器
//特点:不能回头
val list8=List ("A","B","C")
val (it8,it9)=list8.iterator.duplicate
while (it8.hasNext){
println(it8.next())
}
println("-"*20)
println(it9.next())
println("-"*20)
//把迭代器中剩余的数据保存到List中
val list9=List(1,2,3,4)
val it10=list9.iterator
it10.next()
it10.next()
val list10 =it10.toList
println(list10)
//zip:拉链
//作用:把两个迭代器组合成一个,以短的为准
val it11=List(1,2,3,4,5,6,6,7,8).iterator
val it12=List("one","two","there","four","five").iterator
val it13=it11.zip(it12)
while (it13.hasNext){
val rs =it13.next()
println(s"${rs._1}---->${rs._2}")
}
}
}
run......
例题
1.以下关于送代器next方法说法正确的是( C )
A.它总是返回送代器中的第一个元素。
B.它返回送代器中的下一个元素,并将送代器位置向前移动一位,如果没有会返回None。
C.它返回送代器中的下一个元素,并将送代器位置向前移动一位,如果没有会抛出NoSuchElementException.
D.它可以返回送代器中的任意一个元素。
分析:在 Scala 中,迭代器的next方法返回迭代器中的下一个元素,并将迭代器位置向前移动一位。如果没有下一个元素,会抛出NoSuchElementException。选项 A 错误,它不是总是返回第一个元素;选项 B 错误,没有下一个元素时不会返回None,而是抛出异常;选项 D 错误,它是按顺序返回下一个元素,不是任意一个元素。
2.duplicate方法创建的迭代器副本与原迭代器( C )
A.共享元素序列,修改其中一个会影响另一个。
B.不共享元素序列,修改其中一个不会影响另一个。
C.共享元素序列,但修改其中一个不会影响另一个。
D.没有任何关系
分析:duplicate方法创建的迭代器副本与原迭代器共享元素序列。对其中一个迭代器的操作会影响另一个,因为它们本质上是在同一个元素序列上进行遍历。
3.对于zip方法,当两个选代器台长度不同时( B )
A.会自动补齐较短的迭代器,使其长度与较长的迭代器相同。
B.会在较短的迭代器耗尽时停上zip操作。
C.会抛出异常。
D.会重复使用较短的迭代器元素,直到与较长的送代器长度相同。
分析:对于zip方法,当两个迭代器长度不同时,会在较短的迭代器耗尽时停止zip操作。选项 A 错误,不会自动补齐;选项 C 错误,一般不会抛出异常;选项 D 错误,不会重复使用较短的迭代器元素来补齐
4.toList方法对迭代器的作用是( B )
A.将迭代器中的所有元素转换为一个列表,包括已经遍历过的元素。
B.将迭代器中的剩余元素转换为一个列表。
C.将列表转换为迭代器。
D.将选代器转换为一个不可变的集合。
分析:toList方法是将迭代器中的剩余元素转换为一个列表。选项 A 错误,不是包括已经遍历过的元素;选项 C 错误,它不是将列表转换为迭代器;选项 D 错误,它只是转换为列表,不是转换为不可变的集合这种说法不准确。
5.使用drop方法创建的子送代器( B )
A.包含原迭代器的所有元素。
B.从原迭代器的开头开始,跳过指定数量的元素后包含剩余的元素。
C.包含原选代器中指定数量的元素,从开头开始。
D.是原迭代器的一个副本,不跳过任何元素
分析:使用drop方法创建的子迭代器是从原迭代器的开头开始,跳过指定数量的元素后包含剩余的元素。选项 A 错误,不是包含所有元素;选项 C 错误,不是从开头包含指定数量的元素;选项 D 错误,会跳过指定数量的元素,不是不跳过任何元素。
6.迭代器课后练习:
————————————————
package Scala_CSDN.十一月
// 1. 创建表示学生信息的类并初始化学生对象列表
case class Student(name: String, age: Int, scores: List[Double])
object 迭代器1 {
def main(args: Array[String]): Unit = {
// 创建学生对象并存储在列表中
val studentList = List(
Student("小张", 18, List(88.0, 85.0, 90.0)),
Student("小卢", 18, List(90.0, 97.0, 85.0)),
Student("小王", 19, List(98.0, 80.0, 95.0)),
Student("小朱", 21, List(90.0, 85.0, 90.0)),
Student("小沈", 19, List(88.0, 90.0, 90.0))
)
// 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(student => student.scores(2) > 80)
println("年龄大于20岁的同学:")
filteredByAge.foreach(student => println(s"姓名: ${student.name}, 年龄: ${student.age}"))
println("语文成绩大于80分的同学:")
filteredByChineseScore.foreach(student => println(s"姓名: ${student.name}, 语文成绩: ${student.scores(2)}"))
// 4. 使用zip方法关联信息
val averageScoresList = studentList.map(student => student.scores.sum / student.scores.size)
val averageScoresIterator = averageScoresList.iterator
val zippedIterator = studentList.iterator.zip(averageScoresIterator)
println("学生姓名和平均成绩:")
zippedIterator.foreach { case (student, averageScore) =>
println(s"姓名: ${student.name}, 平均成绩: ${averageScore}")
}
// 5. 打印前三名的同学信息
val topThreeStudents = studentList.sortBy(-_.scores.sum).take(3)
println("前三名同学信息:")
topThreeStudents.foreach(student => println(s"姓名: ${student.name}, 年龄: ${student.age}, 成绩总和: ${student.scores.sum}"))
// 6. 打印从第4名开始的后3位同学的信息
val fourthAndNextThreeStudents = studentList.sortBy(_.scores.sum).drop(3).take(3)
println("从第4名开始的后3位同学信息:")
fourthAndNextThreeStudents.foreach(student => println(s"姓名: ${student.name}, 年龄: ${student.age}, 成绩总和: ${student.scores.sum}"))
// 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 = 90.0
val filteredStudents = studentList.iterator.filter(student => student.scores.exists(_ > specificScore))
println(s"成绩中有至少一个${specificScore}分以上的学生信息:")
filteredStudents.foreach(student => println(s"姓名: ${student.name}, 年龄: ${student.age}"))
}
}
标签:迭代,val,Scala,元素,next,student,println
From: https://blog.csdn.net/2301_82118291/article/details/143856770