Scala数据结构

一、数组（Array）

数组集合特点：元素具有相同的类型

声明一个整形数组：

scala> val intValueArr=new Array[Int](3)
intValueArr: Array[Int] = Array(0, 0, 0)

scala> intValueArr(0)=12

scala> intValueArr(1)=45

scala> intValueArr(2)=33

1
2
3
4
5
6
7
8
9

声明一个字符串数组：

scala> val myStrArr=new Array[String](3)
myStrArr: Array[String] = Array(null, null, null)

scala> myStrArr(0)="BigData"

scala> myStrArr(1)="Hadoop"

scala> myStrArr(2)="Spark"

scala> for(i <-0 to 2)println(myStrArr(i))
BigData
Hadoop
Spark
1
2
3
4
5
6
7
8
9
10
11
12
13

多维数组的创建：调用Array的ofDim方法

scala> val myMatrix = Array.ofDim[Int](3,4)
myMatrix: Array[Array[Int]] = Array(Array(0, 0, 0, 0), Array(0, 0, 0, 0), Array(0, 0, 0, 0))

scala> val myCube= Array.ofDim[String](3,2,4)
myCube: Array[Array[Array[String]]] = Array(Array(Array(null, null, null, null), Array(null, null, null, null)), Array(Array(null, null, null, null), Array(null, null, null, null)), Arr
ay(Array(null, null, null, null), Array(null, null, null, null)))

1
2
3
4
5
6
7

二、元组（Tuple）

需要返回多个类型不同的对象时可以使用元组

scala> val tuple=("BigData",2015,45,0)
tuple: (String, Int, Int, Int) = (BigData,2015,45,0)

scala> println(tuple._1)
BigData

scala> println(tuple._2)
2015

scala> println(tuple._3)
45

1
2
3
4
5
6
7
8
9
10
11
12

三、容器（Collection）

容器的三个包：

• scala.collection
  是封装了可变容器可不可变容器的超类（特质Trait），定义了一些可变容器和不可变的一些通用操作。

• scala.collection.mutable

• scala.collection.immutable

• seq：按0，1，2索引

• Map：按键索引

• Set：无索引结构

四、序列（Sequence）

• LinearSeq：取头或取尾巴操作，列表、队列继承于它。
• IndexedSeq：有高效的随机存取操作，ArrayBuffer、Vector继承于它。

4.1列表（List）：

具体的容器类，共享相同类型的不可变的对象序列；列表的值不可变，定义在scala.collection.immutable下，在声明时必须给它初始化。

var strList = List("BigData", "Hadoop", "Spark")
1

在列表中使用head、tail：

• head访问头部

scala> strList.head
res3: String = BigData
1
2

• tail访问尾部（除了第一个元素的所有元素）

scala> strList.tail
res4: List[String] = List(Hadoop, Spark)
1
2

构造列表的方法：

向已有列表前端增加元素

scala> val otherList="Apache"::strList
otherList: List[String] = List(Apache, BigData, Hadoop, Spark)
1
2

快速得到一个列表

scala> val intList=List(1,2,3)
intList: List[Int] = List(1, 2, 3)
1
2

scala> val intList=1::2::3::Nil//右结合，从右往左执行
intList: List[Int] = List(1, 2, 3)
1
2

4.2向量（Vector）

scala> val vec1=Vector(1,2)
vec1: scala.collection.immutable.Vector[Int] = Vector(1, 2)

scala> val vec2=3+:4+:vec1
vec2: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2)

scala> val vec3=vec2:+5
vec3: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2, 5)

scala> vec3(3)
res5: Int = 2

1
2
3
4
5
6
7
8
9
10
11
12

注意冒号一定要在向量哪一侧否侧会报错，如下：

scala> val vec4=vec3+:9
<console>:12: error: value +: is not a member of Int
       val vec4=vec3+:9
                    ^
1
2
3
4

调整位置后又可以了：

scala> val vec4=vec3:+9
vec4: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2, 5, 9)
1
2

4.3Range

Range是一种特殊的带索引的不可变数字等差序列。

起点 to 终点 by 步长
1

Range支持：

• 整形序列
• 字符型序列
• 单精度浮点型序列

Range案例1：
创建一个从1到5的数值序列包含区间终点5步长为1。

scala> val r=new Range(1,5,1)
r: scala.collection.immutable.Range = Range 1 until 5

scala> 1 to 5
res6: scala.collection.immutable.Range.Inclusive = Range 1 to 5

scala> 1.to(5)
res7: scala.collection.immutable.Range.Inclusive = Range 1 to 5

1
2
3
4
5
6
7
8
9

Range案例2：
创建一个从1到5的数字序列不包含区间终点，步长为1

scala> 1 until 5
res8: scala.collection.immutable.Range = Range 1 until 5

1
2
3

Range案例3：
创建一个从1到10的数字序列包含区间终点10，步长是2

scala> 1 to 10 by 2
res9: scala.collection.immutable.Range = inexact Range 1 to 10 by 2
1
2

Range案例4：
创建一个Float类型的数值序列从0.5到5.9，步长是0.3

scala> 0.5f to 5.9f by 0.3f
<console>:12: warning: method to in trait FractionalProxy is deprecated (since 2.12.6): u
se BigDecimal range instead
       0.5f to 5.9f by 0.3f
            ^
res13: scala.collection.immutable.NumericRange[Float] = NumericRange 0.5 to 5.9 by 0.3

scala> res13.toBuffer
res14: scala.collection.mutable.Buffer[Float] = ArrayBuffer(0.5, 0.8, 1.1, 1.4000001, 1.7
, 2.0, 2.3000002, 2.6000001, 2.9, 3.2, 3.5, 3.8000002, 4.1000004, 4.4, 4.7000003, 5.0, 5.
3, 5.6000004)

1
2
3
4
5
6
7
8
9
10
11
12

我们可以看到出现报错，原因是Scala2.12.6以后的版本作出了调整这里使用toBuffer实现展示。

五、集合（Set）

• 可变集：scala.collection.mutable包
• 不可变集：scala.collection.immutable包

可变类型的变量

不可变集：

var mySet=Set("Hadoop","Spark")
//这种是不可变集合，从集合上来讲缺省情况下创建是不可变集
1
2

从集合上来讲缺省情况下创建是不可变集，Set("Hadoop","Spark")是一个不可变集合对象；变量mySet它是一个可变类型的变量（可以去变更它的值）。开始可把一个不可变集赋值给一个可变的变量，后面可以再修改这个变量的变量值。

scala> mySet+="Scala"

scala> mySet
res16: scala.collection.immutable.Set[String] = Set(Hadoop, Spark, Scala)
1
2
3
4

mySet本身是一个可变的变量，开始指向一个不可变集；mySet+=“Scala"会在这个不可变集基础之上又增加一个元素Scala生成一个新的不可变集，然后把这个新的不可变集赋值给这个可变的变量mySet；相当于这个mySet前后指针变了一下，开始时指向Set(“Hadoop”,“Spark”)，后面指向Set(“Hadoop”,” Spark", “Scala”)。

可变集：

scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

scala> val myMutableSet =Set("Database","BigData")
myMutableSet: scala.collection.mutable.Set[String] = Set(BigData, Database)

scala> myMutableSet +="Cloud Computing"
res17: myMutableSet.type = Set(BigData, Cloud Computing, Database)
1
2
3
4
5
6
7
8

前后两种情况，一种是可变量改变指向；另一种是将不可变量指向的数据集给改了。

六、映射（Map）

• 可变映射：scala.collection.mutable包
• 不可变映射：scala.collection.immutable包

默认情况下使用不可变映射，如果想用可变映射要明确导入scala.collection.mutable.Map包。

不可变映射：

scala> val university = Map("XMU"->"Xiamen University","THU"->"Tsinghua University","PKU"
->"Peking University")
university: scala.collection.immutable.Map[String,String] = Map(XMU -> Xiamen University,
 THU -> Tsinghua University, PKU -> Peking University)

scala> println(university("XMU"))
Xiamen University

1
2
3
4
5
6
7
8

如果"XMU"这键不存在则会报错，为了避免这种情况可以先调用contains方法确定键是否存在。

scala> val xmu = if (university.contains("XMU")) university("XMU") else 0
xmu: Any = Xiamen University

scala> println(xmu)
Xiamen University
1
2
3
4
5

可变映射：

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map

scala> val university2 = Map("XMU"->"Xiamen University","THU"->"Tsinghua University","PKU
"->"Peking University")
university2: scala.collection.mutable.Map[String,String] = Map(XMU -> Xiamen University,
THU -> Tsinghua University, PKU -> Peking University)

scala> university2("XMU")="Ximan University"//更新已有元素值

scala> university2("FZU")="Fuzhou University"//添加新元素
1
2
3
4
5
6
7
8
9
10
11

用加等于来添加新的元素

scala> university2 += ("TJU"->"Tianjin University")//添加一个新元素
res26: university2.type = Map(XMU -> Ximan University, THU -> Tsinghua University, FZU ->
 Fuzhou University, TJU -> Tianjin University, PKU -> Peking University)

scala> university2 += ("SDU"->"Shandong University","WHU"->"Wuhan University")//同时添加两个新元素
res27: university2.type = Map(XMU -> Ximan University, SDU -> Shandong University, WHU ->
 Wuhan University, THU -> Tsinghua University, FZU -> Fuzhou University, TJU -> Tianjin U
niversity, PKU -> Peking University)
1
2
3
4
5
6
7
8

七、迭代器（Iterator）

Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。
迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环：

object Iterator_test {
  def main(args: Array[String]): Unit = {
    val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
    while (it.hasNext){
      println(it.next())
    }
  }
}
1
2
3
4
5
6
7
8

Scala中的迭代器还有很多可以前往菜鸟教程学习：链接: https://www.runoob.com/scala/scala-iterators.html