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))
