本文详细介绍了Scala中的数组，包括定长和变长数组的定义、操作和计算方法。接着讲解了元组的定义、访问和常见操作。接下来，探讨了列表，包括不可变和可变列表的特点、操作和转换。最后，阐述了Map的概念，包括不可变和可变Map的定义、操作及遍历。
文章目录
数组
scala中数组的概念是和Java类似，可以用数组来存放一组数据。scala中，有两种数组，一种是定长数组，另一种是变长数组
定长数组
- 定长数组指的是数组的长度是不允许改变的
- 数组的元素是可以改变的
语法
// 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)
// 用元素直接初始化数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)
[!NOTE]
- 在scala中，数组的泛型使用
[]来指定- 使用
()来获取元素
示例一
- 定义一个长度为100的整型数组
- 设置第1个元素为110
- 打印第1个元素
参考代码
scala> val a = new Array[Int](100)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
scala> a(0) = 110
scala> println(a(0))
110
示例二
-
定义一个包含以下元素的数组
"java", "scala", "python" -
获取数组长度
参考代码
// 定义包含jave、scala、python三个元素的数组
scala> val a = Array("java", "scala", "python")
a: Array[String] = Array(java, scala, python)
scala> a.length
res17: Int = 3
# 变长数组
变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素
定义变长数组
创建变长数组，需要提前导入ArrayBuffer类import scala.collection.mutable.ArrayBuffer
语法
-
创建空的ArrayBuffer变长数组，语法结构：
val/var a = ArrayBuffer[元素类型]() -
创建带有初始元素的ArrayBuffer
val/var a = ArrayBuffer(元素1，元素2，元素3....)
示例一
定义一个长度为0的整型变长数组
参考代码
val a = ArrayBuffer[Int]()
示例二
定义一个包含以下元素的变长数组
"hadoop", "storm", "spark"
参考代码
scala> val a = ArrayBuffer("hadoop", "storm", "spark")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)
添加/修改/删除元素
- 使用
+=添加元素 - 使用
-=删除元素 - 使用
++=追加一个数组到变长数组
示例
- 定义一个变长数组，包含以下元素: “hadoop”, “spark”, “flink”
- 往该变长数组添加一个"flume"元素
- 从该变长数组删除"hadoop"元素
- 再将一个数组，该数组包含"hive", "sqoop"追加到变长数组中
参考代码
// 定义变长数组
scala> val a = ArrayBuffer("hadoop", "spark", "flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)
// 追加一个元素
scala> a += "flume"
res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)
// 删除一个元素
scala> a -= "hadoop"
res11: a.type = ArrayBuffer(spark, flink, flume)
// 追加一个数组
scala> a ++= Array("hive", "sqoop")
res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)
# 遍历数组
可以使用以下两种方式来遍历数组：
- 使用
for表达式直接遍历数组中的元素 - 使用
索引遍历数组中的元素
示例一
- 定义一个数组，包含以下元素1,2,3,4,5
- 使用for表达式直接遍历，并打印数组的元素
参考代码
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i<-a) println(i)
1
2
3
4
5
示例二
- 定义一个数组，包含以下元素1,2,3,4,5
- 使用for表达式基于索引下标遍历，并打印数组的元素
参考代码
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i <- 0 to a.length - 1) println(a(i))
1
2
3
4
5
scala> for(i <- 0 until a.length) println(a(i))
1
2
3
4
5
[!NOTE]
0 until n——生成一系列的数字，包含0，不包含n；左闭右开
0 to n ——包含0，也包含n
# 数组常用算法
scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。以下为常用的几个算法：
-
求和——sum方法
-
求最大值——max方法
-
求最小值——min方法
-
排序——sorted方法
求和
数组中的sum方法可以将所有的元素进行累加，然后得到结果
示例
- 定义一个数组，包含以下几个元素（1,2,3,4)
- 请计算该数组的和
参考代码
scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> a.sum
res49: Int = 10
最大值
数组中的max方法，可以获取到数组中的最大的那个元素值
示例
- 定义一个数组，包含以下几个元素（4,1,2,4,10）
- 获取数组的最大值
参考代码
scala> val a = Array(4,1,2,4,10)
a: Array[Int] = Array(4, 1, 2, 4, 10)
scala> a.max
res50: Int = 10
最小值
数组的min方法，可以获取到数组中最小的那个元素值
示例
- 定义一个数组，包含以下几个元素（4,1,2,4,10）
- 获取数组的最小值
参考代码
scala> val a = Array(4,1,2,4,10)
a: Array[Int] = Array(4, 1, 2, 4, 10)
scala> a.min
res51: Int = 1
排序
数组的sorted方法，可以对数组进行升序排序。而reverse方法，可以将数组进行反转，从而实现降序排序
示例
- 定义一个数组，包含以下几个元素（4,1,2,4,10）
- 对数组进行升序排序、降序排序
参考代码
// 升序排序
scala> a.sorted
res53: Array[Int] = Array(1, 2, 4, 4, 10)
// 降序
scala> a.sorted.reverse
res56: Array[Int] = Array(10, 4, 4, 2, 1)
元组
元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。
定义元组
语法
使用括号来定义元组
val/var 元组 = (元素1, 元素2, 元素3....)
使用箭头来定义元组（元组只有两个元素）
val/var 元组 = 元素1->元素2
示例
定义一个元组，包含一个学生的以下数据
| id | 姓名 | 年龄 | 地址 |
|---|---|---|---|
| 1 | zhangsan | 20 | beijing |
参考代码
scala> val a = (1, "zhangsan", 20, "beijing")
a: (Int, String, Int, String) = (1,zhangsan,20,beijing)
示例
- 定义一个元组，包含学生的姓名和年龄（zhangsan、20）
- 分别使用括号、和箭头来定义元组
参考代码
scala> val a = ("zhangsan", 20)
a: (String, Int) = (zhangsan,20)
scala> val a = "zhangsan" -> 20
a: (String, Int) = (zhangsan,20)
访问元组
使用_1、_2、_3…来访问元组中的元素，_1表示访问第一个元素，依次类推
示例
- 定义一个元组，包含一个学生的姓名和性别，“zhangsan”, “male”
- 分别获取该学生的姓名和性别
参考代码
scala> val a = "zhangsan" -> "male"
a: (String, String) = (zhangsan,male)
// 获取第一个元素
scala> a._1
res41: String = zhangsan
// 获取第二个元素
scala> a._2
res42: String = male
# 列表
列表是scala中最重要的、也是最常用的数据结构。List具备以下性质：
- 可以保存重复的值
- 有先后顺序
在scala中，也有两种列表，一种是不可变列表、另一种是可变列表
定义
不可变列表就是列表的元素、长度都是不可变的。
语法
使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表，语法格式：
val/var 变量名 = List(元素1, 元素2, 元素3...)
使用Nil创建一个不可变的空列表
val/var 变量名 = Nil
使用::方法创建一个不可变列表
val/var 变量名 = 元素1 :: 元素2 :: Nil
[!TIP]
使用**::拼接方式来创建列表，必须在最后添加一个Nil**
Nil即空集合List()
示例一
创建一个不可变列表，存放以下几个元素（1,2,3,4）
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
示例二
使用Nil创建一个不可变的空列表
参考代码
scala> val a = Nil
a: scala.collection.immutable.Nil.type = List()
示例三
使用::方法创建列表，包含-2、-1两个元素
参考代码
scala> val a = -2 :: -1 :: Nil
a: List[Int] = List(-2, -1)
可变列表
可变列表就是列表的元素、长度都是可变的。
要使用可变列表，先要导入import scala.collection.mutable.ListBuffer
[!NOTE]
- 可变集合都在
mutable包中- 不可变集合都在
immutable包中（默认导入）
定义
使用ListBuffer[元素类型]()创建空的可变列表，语法结构：
val/var 变量名 = ListBuffer[Int]()
使用ListBuffer(元素1, 元素2, 元素3…)创建可变列表，语法结构：
val/var 变量名 = ListBuffer(元素1，元素2，元素3...)
示例一
创建空的整形可变列表
参考代码
scala> val a = ListBuffer[Int]()
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
示例二
创建一个可变列表，包含以下元素：1,2,3,4
参考代码
scala> val a = ListBuffer(1,2,3,4)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
可变列表操作
- 获取元素（使用括号访问
(索引值)） - 添加元素（
+=） - 追加一个列表（
++=） - 更改元素（
使用括号获取元素，然后进行赋值） - 删除元素（
-=） - 转换为List（
toList） - 转换为Array（
toArray）
示例
- 定义一个可变列表包含以下元素：1,2,3
- 获取第一个元素
- 添加一个新的元素：4
- 追加一个列表，该列表包含以下元素：5,6,7
- 删除元素7
- 将可变列表转换为不可变列表
- 将可变列表转换为数组
参考代码
// 导入不可变列表
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
// 创建不可变列表
scala> val a = ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
// 获取第一个元素
scala> a(0)
res19: Int = 1
// 追加一个元素
scala> a += 4
res20: a.type = ListBuffer(1, 2, 3, 4)
// 追加一个列表
scala> a ++= List(5,6,7)
res21: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)
// 删除元素
scala> a -= 7
res22: a.type = ListBuffer(1, 2, 3, 4, 5, 6)
// 转换为不可变列表
scala> a.toList
res23: List[Int] = List(1, 2, 3, 4, 5, 6)
// 转换为数组
scala> a.toArray
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)
# 列表常用操作
以下是列表常用的操作
- 判断列表是否为空（
isEmpty） - 拼接两个列表（
++） - 获取列表的首个元素（
head）和剩余部分(tail) - 反转列表（
reverse） - 获取前缀（
take）、获取后缀（drop） - 扁平化（
flaten） - 拉链（
zip）和拉开（unzip） - 转换字符串（
toString） - 生成字符串（
mkString） - 并集（
union） - 交集（
intersect） - 差集（
diff）
判断列表是否为空
示例
- 定义一个列表，包含以下元素：1,2,3,4
- 使用isEmpty判断列表是否为空
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> a.isEmpty
res51: Boolean = false
拼接两个列表
示例
- 有两个列表，分别包含以下元素1,2,3和4,5,6
- 使用
++将两个列表拼接起来
参考代码
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)
scala> a ++ b
res52: List[Int] = List(1, 2, 3, 4, 5, 6)
获取列表的首个元素和剩余部分
示例
- 定义一个列表，包含以下几个元素：1,2,3
- 使用head方法，获取列表的首个元素
- 使用tail方法，获取除第一个元素以外的元素，它也是一个列表
参考代码
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> a.head
res4: Int = 1
scala> a.tail
res5: List[Int] = List(2, 3)
反转列表
示例
- 定一个列表，包含以下元素：1,2,3
- 使用reverse方法将列表的元素反转
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> a.reverse
res6: List[Int] = List(3, 2, 1)
获取列表前缀和后缀
示例
- 定义一个列表，包含以下元素：1,2,3,4,5
- 使用take方法获取前缀（前三个元素）：1,2, 3
- 使用drop方法获取后缀（除前三个以外的元素）：4,5
参考代码
scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)
scala> a.take(3)
res56: List[Int] = List(1, 2, 3)
scala> a.drop(3)#除前三位之外的所有元素为后缀列表元素
res60: List[Int] = List(4, 5)
扁平化(压平)
扁平化表示将列表中的列表中的所有元素放到一个列表中。
[外链图片转存失败(img-KEOo6iw9-1569033674395)(assets/1557063067562.png)]
示例
- 有一个列表，列表中又包含三个列表，分别为：List(1,2)、List(3)、List(4,5)
- 使用flatten将这个列表转换为List(1,2,3,4,5)
参考代码
scala> val a = List(List(1,2), List(3), List(4,5))
a: List[List[Int]] = List(List(1, 2), List(3), List(4, 5))
scala> a.flatten
res0: List[Int] = List(1, 2, 3, 4, 5)
拉链与拉开
- 拉链：使用zip将两个列表，组合成一个元素为元组的列表
- 拉开：将一个包含元组的列表，解开成包含两个列表的元组
示例
- 有两个列表
- 第一个列表保存三个学生的姓名，分别为：zhangsan、lisi、wangwu
- 第二个列表保存三个学生的年龄，分别为：19, 20, 21
- 使用zip操作将两个列表的数据"拉"在一起，形成 zhangsan->19, lisi ->20, wangwu->21
参考代码
scala> val a = List("zhangsan", "lisi", "wangwu")
a: List[String] = List(zhangsan, lisi, wangwu)
scala> val b = List(19, 20, 21)
b: List[Int] = List(19, 20, 21)
scala> a.zip(b)
res1: List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21))
scala>val b1 = ArrayBuffer(1,2,3)
scala>val b2 = ArrayBuffer(3,4,5,6,)
scala>b1.zipAll(b2,-1,-2) //(1,3)(2,4)(3,5)(-1,-2)
示例
- 将上述包含学生姓名、年龄的元组列表，解开成两个列表
参考代码
scala> res1.unzip # 返回元组
res2: (List[String], List[Int]) = (List(zhangsan, lisi, wangwu),List(19, 20, 21))
转换字符串
toString方法可以返回List中的所有元素
示例
- 定义一个列表，包含以下元素：1,2,3,4
- 使用toString输出该列表的元素
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> println(a.toString)
List(1, 2, 3, 4)
生成字符串
mkString方法，可以将元素以分隔符拼接起来。默认没有分隔符
示例
- 定义一个列表，包含以下元素1,2,3,4
- 使用mkString，用冒号将元素都拼接起来
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> a.mkString
res7: String = 1234
scala> a.mkString(":")
res8: String = 1:2:3:4
并集
union表示对两个列表取并集，不去重
示例
- 定义第一个列表，包含以下元素：1,2,3,4
- 定义第二个列表，包含以下元素：3,4,5,6
- 使用union操作，获取这两个列表的并集
- 使用distinct操作，去除重复的元素
参考代码
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
// 并集操作
scala> a1.union(a2)
res17: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)
// 可以调用distinct去重
scala> a1.union(a2).distinct
res18: List[Int] = List(1, 2, 3, 4, 5, 6)
交集
intersect表示对两个列表取交集
示例
- 定义第一个列表，包含以下元素：1,2,3,4
- 定义第二个列表，包含以下元素：3,4,5,6
- 使用intersect操作，获取这两个列表的交集
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
scala> a1.intersect(a2)
res19: List[Int] = List(3, 4)
差集
diff表示对两个列表取差集，例如： a1.diff(a2)，表示获取a1在a2中不存在的元素
示例
- 定义第一个列表，包含以下元素：1,2,3,4
- 定义第二个列表，包含以下元素：3,4,5,6
- 使用diff获取这两个列表的差集
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
scala> a1.diff(a2)
res24: List[Int] = List(1, 2)
# Set
Set(集)是代表没有重复元素的集合。Set具备以下性质：
- 元素不重复
- 不保证插入顺序
scala中的集也分为两种，一种是不可变集，另一种是可变集。
不可变集
定义
语法
创建一个空的不可变集，语法格式：
val/var 变量名 = Set[类型]()
给定元素来创建一个不可变集，语法格式：
val/var 变量名 = Set(元素1, 元素2, 元素3...)
示例一
定义一个空的不可变集
参考代码
scala> val a = Set[Int]()
a: scala.collection.immutable.Set[Int] = Set()
示例二
定义一个不可变集，保存以下元素：1,1,3,2,4,8
参考代码
scala> val a = Set(1,1,3,2,4,8)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 8, 4)
基本操作
- 获取集的大小（
size） - 遍历集（
和遍历数组一致） - 添加一个元素，生成一个Set（
+） - 拼接两个集，生成一个Set（
++） - 拼接集和列表，生成一个Set（
++）
示例
- 创建一个集，包含以下元素：1,1,2,3,4,5
- 获取集的大小
- 遍历集，打印每个元素
- 删除元素1，生成新的集
- 拼接另一个集（6, 7, 8)
- 拼接一个列表(6,7,8, 9)
参考代码
// 创建集
scala> val a = Set(1,1,2,3,4,5)
a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
// 获取集的大小
scala> a.size
res0: Int = 5
// 遍历集
scala> for(i <- a) println(i)
// 删除一个元素
scala> a - 1
res5: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)
// 拼接两个集
scala> a ++ Set(6,7,8)
res2: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
// 拼接集和列表
scala> a ++ List(6,7,8,9)
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
# 可变集
定义
可变集合不可变集的创建方式一致，只不过需要提前导入一个可变集类。
手动导入：import scala.collection.mutable.Set
示例
- 定义一个可变集，包含以下元素: 1,2,3, 4
- 添加元素5到可变集中
- 从可变集中移除元素1
参考代码
scala> val a = Set(1,2,3,4)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
// 添加元素
scala> a += 5
res25: a.type = Set(1, 5, 2, 3, 4)
// 删除元素
scala> a -= 1
res26: a.type = Set(5, 2, 3, 4)
# 映射
Map可以称之为映射。它是由键值对组成的集合。在scala中，Map也分为不可变Map和可变Map。
不可变Map
定义
- 值和长度都不可变
语法
val/var map = Map(键->值, 键->值, 键->值...) // 推荐，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)
示例
-
定义一个映射，包含以下学生姓名和年龄数据
"zhangsan", 30 "lisi", 40 -
获取zhangsan的年龄
参考代码
scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)
scala> val map = Map(("zhangsan", 30), ("lisi", 30))
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 30)
// 根据key获取value
scala> map("zhangsan")
res10: Int = 30
可变Map
定义
定义语法与不可变Map一致。但定义可变Map需要手动导入import scala.collection.mutable.Map
示例
-
定义一个映射，包含以下学生姓名和年龄数据
"zhangsan", 30 "lisi", 40 -
修改zhangsan的年龄为20
scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
// 修改value
scala> map("zhangsan") = 20
Map基本操作
基本操作
- 获取值(
map(key)) - 获取所有key（
map.keys） - 获取所有value（
map.values） - 遍历map集合
- getOrElse
- 增加key,value对
- 删除key
示例
-
定义一个映射，包含以下学生姓名和年龄数据
"zhangsan", 30 "lisi", 40 -
获取zhangsan的年龄
-
获取所有的学生姓名
-
获取所有的学生年龄
-
打印所有的学生姓名和年龄
-
获取wangwu的年龄，如果wangwu不存在，则返回-1
-
新增一个学生：wangwu, 35
-
将lisi从可变映射中移除
参考代码
scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
// 获取zhagnsan的年龄
scala> map("zhangsan")
res10: Int = 30
// 获取所有的学生姓名
scala> map.keys
res13: Iterable[String] = Set(lisi, zhangsan)
// 获取所有的学生年龄
scala> map.values
res14: Iterable[Int] = HashMap(40, 30)
// 打印所有的学生姓名和年龄
scala> for((x,y) <- map) println(s"$x $y")
lisi 40
zhangsan 30
// 获取wangwu的年龄，如果wangwu不存在，则返回-1
scala> map.getOrElse("wangwu", -1)
res17: Int = -1
// 新增一个学生：wangwu, 35
scala> map + "wangwu"->35
res22: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangwu -> 35)
// 将lisi从可变映射中移除
scala> map - "lisi"
res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)
# iterator迭代器
scala针对每一类集合都提供了一个迭代器（iterator）用来迭代访问集合
使用迭代器遍历集合
- 使用
iterator方法可以从集合获取一个迭代器 - 迭代器的两个基本操作
- hasNext——查询容器中是否有下一个元素
- next——返回迭代器的下一个元素，如果没有，抛出NoSuchElementException
- 每一个迭代器都是有状态的
- 迭代完后保留在最后一个元素的位置
- 再次使用则抛出NoSuchElementException
- 可以使用while或者for来逐个返回元素
示例
- 定义一个列表，包含以下元素：1,2,3,4,5
- 使用while循环和迭代器，遍历打印该列表
参考代码
scala> val ite = a.iterator
ite: Iterator[Int] = non-empty iterator
scala> while(ite.hasNext) {
| println(ite.next)
| }
示例
- 定义一个列表，包含以下元素：1,2,3,4,5
- 使用for 表达式和迭代器，遍历打印该列表
参考代码
scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)
scala> for(i <- a) println(i)
扫一扫
598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
