容器

添码座原创大约 5 分钟

Scala 2集合也分为可变集合和不可变集合两类。

可变集合：就是集合中的元素可以动态修改，位于scala.collection.mutable包。
不可变集合：是在集合初始化元素之后就不能再修改，位于scala.collection.immutable包。

如果创建集合时不指定包名，则默认会使用不可变集合。

Set

和Java一样，Scala 2中的Set集合也没有重复元素。

Set既是trait，又是object。

scala> var set = Set(1, 2, 3, 3, 4)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> set += 5
res1: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

// 可以显式指定包名
scala> var set = scala.collection.immutable.Set(1, 2, 3, 3, 4)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> var set = scala.collection.mutable.Set(1, 2, 3, 3, 4)
set: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

scala> set += 5
res2: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)

scala> for (i <- set) {
     |     println(i)
     | }
1
5
2
3
4

List

List是一种不可变集合。

scala> var list = List(1, 2, 3, 4)
list: List[Int] = List(1, 2, 3, 4)

scala> list.head
res0: Int = 1

scala> list.tail
res1: List[Int] = List(2, 3, 4)

scala> list.head :: list.tail
res2: List[Int] = List(1, 2, 3, 4)

scala> for (i <- list) {
     |     println(i)
     | }
1
2
3
4

scala> var lb = scala.collection.mutable.ListBuffer[Int]()
lb: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

scala> lb += 1
res4: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1)

scala> lb += 2
res5: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2)

scala> lb += 3
res6: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

scala> lb += 4
res7: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

scala> lb -= 3
res8: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 4)

scala> for (i <- lb) {
     |     println(i)
     | }
1
2
4

Map

Map是一种键值对（key-value）数据结构，它和Set一样，也分为可变和不可变集合，默认使用的是不可变集合

scala> var users = Map("lixingyun" -> 22, "wanglin" -> 23, "xiaoyan" -> 21)
users: scala.collection.immutable.Map[String,Int] = Map(lixingyun -> 22, wanglin -> 23, xiaoyan -> 21)

scala> users("wanglin")
res0: Int = 23

scala> var users = scala.collection.mutable.Map[String, Int]()
users: scala.collection.mutable.Map[String,Int] = Map()

scala> users += (("lixingyun", 22))
res1: scala.collection.mutable.Map[String,Int] = Map(lixingyun -> 22)

scala> users += ("wanglin" -> 23)
res2: scala.collection.mutable.Map[String,Int] = Map(wanglin -> 23, lixingyun -> 22)

scala> users += (("xiaoyan", 21))
res3: scala.collection.mutable.Map[String,Int] = Map(wanglin -> 23, xiaoyan -> 21, lixingyun -> 22)

scala> users += (("qinyun", 24), ("shihao", 20))
res4: scala.collection.mutable.Map[String,Int] = Map(qinyun -> 24, wanglin -> 23, shihao -> 20, xiaoyan -> 21, lixingyun -> 22)

scala> users += (("luofeng", 19), ("liushen" -> 10000))
res5: scala.collection.mutable.Map[String,Int] = Map(qinyun -> 24, wanglin -> 23, shihao -> 20, xiaoyan -> 21, liushen -> 10000, luofeng -> 19, lixingyun -> 22)

// 防止获取不存在的key时报错
scala> val age = if (users.contains("meidusha")) users("meidusha") else 0
age: Int = 0

// 或者这样获取
scala> val age = users.getOrElse("meidusha", 0)
age: Int = 0

// 这里如果是不可变Map就会报错
scala> users("qinyun") = 23
scala> users("qinyun")
res7: Int = 23

scala> users -= "qinyun"
res8: scala.collection.mutable.Map[String,Int] = Map(wanglin -> 23, shihao -> 20, xiaoyan -> 21, liushen -> 10000, luofeng -> 19, lixingyun -> 22)

scala> users -= ("luofeng", "xiaoyan")
res9: scala.collection.mutable.Map[String,Int] = Map(wanglin -> 23, shihao -> 20, liushen -> 10000, lixingyun -> 22)

scala> users -= ("shihao")
res10: scala.collection.mutable.Map[String,Int] = Map(wanglin -> 23, liushen -> 10000, lixingyun -> 22)

scala> for ((key, value) <- users) {
     |     println("key = " + key + ", value = " + value)
     | }
key = wanglin, value = 23
key = liushen, value = 10000
key = lixingyun, value = 22

scala> for(key <- users.keySet) {
     |     println(key)
     | }
wanglin
liushen
lixingyun

scala> for(value <- users.values) {
     |     println(value)
     | }
23
10000
22

// SortedMap只有不可变对象，所以必须使用全限定名，否则报错
scala> var users = SortedMap[String, Int]()
<console>:11: error: not found: value SortedMap
       var users = SortedMap[String, Int]()
                   ^
scala> var users = scala.collection.immutable.SortedMap[String, Int]()
users: scala.collection.immutable.SortedMap[String,Int] = Map()

Array数组

Scala 2中的Array用的就是Java的数组，因为它们的底层都是基于共同的JVM的。

所以，Java数组的特性也完全适用于Array。

scala> val arr = new Array[Int](10)
arr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> arr(0) = 1

scala> arr
res1: Array[Int] = Array(1, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> val arr = Array(1, 2, 4, 7, 10)
arr: Array[Int] = Array(1, 2, 4, 7, 10)

scala> val arr = Array("hello", "scala")
arr: Array[String] = Array(hello, scala)

scala> arr(0)
res2: String = hello

scala> val arr = Array("hello", "scala", 22)
arr: Array[Any] = Array(hello, scala, 22)

Scala 2中ArrayBuffer和Java中的ArrayList类似，长度可变。

而且ArrayBuffer和ArrayList一样，下标都是从0开始的。

// 可以预先导入，这样就不用在声明时指定全限定名
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val ab = new ArrayBuffer[Int]()
ab: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> ab += 1
res0: ab.type = ArrayBuffer(1)

scala> ab += (2, 3, 5, 7, 8)
res1: ab.type = ArrayBuffer(1, 2, 3, 5, 7, 8)

// 在指定下标的位置添加数据
scala> ab.insert(3, 4)

scala> ab
res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8)

scala> ab.remove(3)
res4: Int = 4

scala> ab
res5: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 5, 7, 8)

Array和ArrayBuffer是可以互相转换的。

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val ab = ArrayBuffer(1, 3, 4, 6, 7)
ab: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 4, 6, 7)

scala> val arr = ab.toArray
arr: Array[Int] = Array(1, 3, 4, 6, 7)

scala> val ba = arr.toBuffer
ba: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 3, 4, 6, 7)

Array和ArrayBuffer的各种运算。

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

// 遍历
scala> val ab = ArrayBuffer(9, 3, 2, 5, 1, 6, 7, 4)
ab: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(9, 3, 2, 5, 1, 6, 7, 4)

scala> for (i <- ab) {
     |     println(i)
     | }
9
3
2
5
1
6
7
4

scala> for (i <- 0 until ab.length) {
     |     println(ab(i))
     | }
9
3
2
5
1
6
7
4

// 聚合
scala> val arr = Array(9, 3, 2, 5, 1, 6, 7, 4)
arr: Array[Int] = Array(9, 3, 2, 5, 1, 6, 7, 4)

scala> val sum = arr.sum
sum: Int = 37

scala> val max = arr.max
max: Int = 9

scala> val min = arr.min
min: Int = 1

// 排序
scala> scala.util.Sorting.quickSort(arr)

scala> arr
res3: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 9)

Tuple称为元组，是Scala 2中用得非常多的一种数据类型，尤其在做大数据处理的时候基本离不开它。

Tuple和Array长度都是不可变的，但Tuple可以存储各种不同类型的元素，而且Tuple的下标是从1开始的。

Scala 2支持的Tuple长度最大为22。

scala> val tuple = (1, 2.0, 3.1415926, "hello scala")
tuple: (Int, Double, Double, String) = (1,2.0,3.1415926,hello scala)

scala> tuple._4
res1: String = hello scala

感谢支持

更多内容，请移步《超级个体》。