Scala - Array & Collection
Scala Array
Scala 语言中提供的数组是用来存储固定大小的同类型元素.
// 两种声明数组的方法
var myArray : Array[String] = new Array[String](3)
var myArray = new Array[String](3)
myArray(0) = "Runoob"; myArray(1) = "Baidu"; myArray(4/2) = "Google"
var myArray = Array("Runoob", "Baidu", "Google")
// 多维数组
var myMatrix = ofDim[Int](3,3)
// 遍历
for ( x <- myArray ) { println( x ) }
for ( i <- 0 to (myArray.length - 1)) { total += myArray(i) }
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// 数组切分
Array("foo", "hoo", "goo", "ioo", "joo").slice(1, 4)
// res6: Array[java.lang.String] = Array(hoo, goo, ioo)
Scala数组基本操作：
| 方法 | 介绍 |
|---|---|
| concat(,) | 合并两个数组 |
| range(,,) | 生成一个区间范围内的数组。range() 方法最后一个参数为步长，默认为 1 |
| ofDimT: Array[T] | 创建指定长度的数组 |
| def ofDimT: Array[Array[T]] | 创建二维数组 |
Array与List的区别： List属于链表型，长度固定元素不可变，删除、插入拼接等操作效率高 Array属于数组型，长度固定元素可变，随机访问快
| 时间复杂度 | 随机访问 | 随机删除 | 随机插入 | 反转 | 拼接 | 计算长度 |
|---|---|---|---|---|---|---|
| Array | O(1) | O(n) | O(n) | O(n) | O(m+n) | O(1) |
| List | O(i) | O(i) | O(i) | O(n) | O(n) | O(n) |
需要快速随机访问或需要count batches of elements,否则，列表比数组更好。
Scala Collection
Scala 集合分为可变的和不可变的集合。 可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。
List列表
Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。
// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
// 构造列表的两个基本单位是 Nil 和 :: , Nil也可以表示为一个空列表。
// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
(0 :: (1 :: (0 :: Nil))) ::
(0 :: (0 :: (1 :: Nil))) :: Nil
Scala列表基本操作：
| 方法 | 介绍 |
|---|---|
| head | 返回列表第一个元素 |
| tail | 返回一个列表，包含除了第一元素之外的其他元素 |
| isEmpty | 在列表为空时返回true |
| reverse | 将列表的顺序反转 |
| ::: | 或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表 |
| fill() | val site = List.fill(3)("Runoob") // 重复 Runoob 3次 |
| tabulate() | val squares = List.tabulate(6)(n => n * n) // List(0, 1, 4, 9, 16, 25)方法的第一个参数为元素的数量，可以是二维的，第二个参数为指定的函数，我们通过指定的函数计算结果并返回值插入到列表中，起始值为 0 |
Set集合
Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，import scala.collection.mutable.Set
默认引用 scala.collection.immutable.Set，不可变集合实例如下：
val set = Set(1,2,3)
println(set.exists(_ % 2 == 0)) //true
println(set.drop(1)) //Set(2,3)
Scala集合基本操作：
| 方法 | 介绍 |
|---|---|
| head | 返回列表第一个元素 |
| tail | 返回一个列表，包含除了第一元素之外的其他元素 |
| isEmpty | 在列表为空时返回true |
| ++ | 或 Set.++() 方法来连接两个集合。如果元素有重复的就会移除重复的元素 |
| min,max | 集合中的最值 |
| &()或intersect() | 查看两个集合的交集元素 |
Map映射
Map(映射)是一种可迭代的键值对（key/value）结构。所有的值都可以通过键来获取，Map 中的键都是唯一的。
默认情况下 Scala 使用不可变 Map（某个key对应的value不可变）。如果你需要使用可变集合，import scala.collection.mutable.Map
你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
A += ('I' -> 1)
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
Scala映射基本操作：
| 方法 | 介绍 |
|---|---|
| keys | 返回 Map 所有的键(key) |
| values | 返回 Map 所有的值(value) |
| isEmpty | 在 Map 为空时返回true |
| ++ | 或 Map.++() 方法来连接两个 Map，Map 合并时会移除重复的 key |
| contains() | 查看 Map 中是否存在指定的 Key |
Tuple元组
元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。目前支持的元组最大长度为 22。
val t = new Tuple3(1, 3.14, "Fred")
// ('u', 'r', "the", 1, 4, "me") 为 Tuple6[Char, Char, String, Int, Int, String]
// 使用 t._1 访问第一个元素， t._2 访问第二个元素
println(t._1)
Scala元组基本操作：
| 方法 | 介绍 |
|---|---|
| productIterator() | 迭代输出元组的所有元素t.productIterator.foreach{} |
| toString() | 将元组的所有元素组合成一个字符串 |
| swap | 只有Tuples2能用。交换元组的元素 |
Option选项
Scala Option(选项)类型用来表示一个值是可选的（有值或无值）。 Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。
val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1") // Some("value1")
val value2: Option[String] = myMap.get("key2") // None
Scala选项基本操作：
| 方法 | 介绍 |
|---|---|
| getOrElse() | 获取元组中存在的元素或者使用其默认的值a.getOrElse(0) |
| productArity | 返回元素个数 |
Iterator迭代器
Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。迭代器 it 的两个基本操作是 next 和 hasNext。 调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。调用 it.hasNext() 用于检测集合中是否还有元素。
// 逐个访问
object Test {
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}
// 可以使用 it.min 和 it.max 方法从迭代器中查找最大与最小元素
// it.size 或 it.length 方法来查看迭代器中的元素个数