Scala 基础（2）—— 基本数据结构

1. Scala 的面向对象

在学习 Java 的时候，我们说 Java 是一门面向对象的语言，然而 Java 其实并没有完全遵守“一切皆对象”这一准则。

例如：Java 的8种基本数据类型 & Java 的数组。

但是 Scala 相比而言，是一门更加纯粹的面向对象的语言，因为它完全遵守“一切皆对象”。

2. 数组 Array

Scala 中定义了数组对象 scala.Array。

我们可以这么初始化一个数组对象：

val array = new Array[String](3)

它的类型是 Array[String]，所以也可以这么定义（不使用类型推断）

val array: Array[String] = new Array[String](3)

如果需要在创建和初始化数组的同时，对其中所有的元素进行赋值，也可以这么做：

val array = Array("1", "2", "3")

这么做从语法上看，可能会有点奇怪，但是它会在编译时调用 Array 伴生对象里一个 apply() 的工厂方法，所以其实质是：

val array = Array.apply("1", "2", "3")

Scala 中使用圆括号 () 而不是方括号[] 来调用数组中的元素：

for (i <- 0 to 2) println(array(i))

这么做的原因也是为了契合 Scala 面向对象的特点，它本质上是调用 Array 对象的 apply() 方法：

for (i <- 0 to 2) println(array.apply(i))

Scala 的数组允许更新其中的元素内容：

array(0) = "0"

它本质上是调用 Array 对象的 update() 方法：

array.update(0, "0")

由此可见，Scala 数组是一个拥有相同类型对象的可变序列，虽然无法在数组实例化之后改变其长度，但是可以改变元素值，所以 Array 是一个可变对象。

3. 列表 List

与数组相对，列表 List 是一个拥有相同类型，即不可改变其长度，又不可改变其元素值得数据结构。

Scala 的 List 与 Java 的 List 不同，它是一个不可变对象。

所以 List 必须在初始化的同时，将 List 里面所有的元素同时完成初始化：

val list = List(1, 2)

val list = List.apply(1, 2) // 与上面等价

由于是不可变对象，List 只能读取不可修改，读取方式和 Array 相同：

for (i <- 0 to 1) println(list(i))

for (i <- 0 to 1) println(list.apply(i)) // 与上面等价

列表 List 支持 :: 和 ::: 操作符来对列表进行拼接。

（Scala 支持使用纯操作符，来作为函数的名字，而这个操作符如果以 : 结尾，那么就认为是右操作元方法，即函数的调用发生在操作符的右侧对象上，反之则是左操作元方法）

双冒号操作符方法，用于在列表最前面添加一个新的元素，返回新的列表：

val list2 = 0 :: list // 结果是 List(0, 1, 2)

val list2 = list.::(0) // 与上面等价

三冒号操作符方法，用于拼接两个列表，返回新的列表：

val list1 = List(1, 2)
val list2 = List(3, 4)
val list3 = list1 ::: list2 // 结果是 List(1, 2, 3, 4)

val list3 = list2.:::(list1) // 与上面等价

空列表用 Nil 表示，通过巧妙地使用 Nil，增加了新的创建列表 List 对象的方式：

val list = 1 :: 2 :: Nil // 结果是 List(1, 2)

4. 元组 Tuple

Array 和 List 都是只能存储同一种数据类型，元组 Tuple 支持存储不同的数据类型。

元组是不可变对象。

元组只有一种初始化方式：

val pair = (1, "Two", Array(1, 2), List("one"))

val pair = Tuple4.apply(1, "Two", Array(1, 2), List("one")) // 与上面等价

Scala 源码中，根据元组的长度，创建了22个对象，从 Tuple1 到 Tuple22。

访问元组元素的方法，是通过英文句点. & 下划线_ & 从1开始的序号：

println(pair._1)
println(pair._2)

• 之所以不能使用类似 pair(1) 来访问元素，是因为 apply() 方法在元组中，不能确定结果类型。
• 之所以从下标1开始访问元组的元素，是为了兼容其他支持元组的语言的使用习惯。

5. 集 Set

与 Java 类似， Scala 中提供集 Set 来存储同一类型、不含重复元素的集合。

Scala 提供了两种集，可变集 scala.collection.mutable.Set 和不可变集  scala.collection.immutable.Set。

其中，不可变集在没有 import 的情况下，为默认实现。

这里的可变性在于：Set 的长度可变，但是每一个元素指向的内容还是不可变的。

集 Set 的初始化方式：

val set = Set("1", "23", "1")

val set = Set.apply("1", "23", "1") // 与上面等价

集 Set 不能通过下标来读取里面的内容，其默认的 apply() 方法的作用是判断入参是否存在于集对象中：

set("1") // 返回 true

如果需要读取 Set 中的元素，需要用到迭代器：

set.foreach(s => println(s))

可以使用 += 来为 Set 添加新的元素

var set = Set("1", "23", "1") // 这里必须定义成 var，因为是不可变 Set
set += "33"

val set = scala.collection.mutable.Set("1", "23", "1")
set += "33"

6. 映射 Map

Map 映射用来存储两个对象之间的映射关系。

和 Set 相同，Scala 提供了可变映射 scala.collection.mutable.Map 和不可变映射  scala.collection.immutable.Map，不可变映射为默认实现。

映射 Map 的初始化方式，通过 -> 表达映射关系：

val map = Map(1 -> "1", 2 -> "2")

通过 += 操作符为 Map 添加映射关系：

var map = Map(1 -> "1", 2 -> "2") // 因为不可变 Map，所以必须是 var
map += 1 -> "0"

如果 添加的 key 值相同，后者会取代前者，例如下面的例子输出就是0：

var map = Map(1 -> "1", 2 -> "2")
map += 1 -> "0"
println(map.apply(1))