Scala的集合体系

首先看一下整个集合体系结构，这个结构与Java的集合体系非常相似

集合的顶层接口是Iterable，Iterable接口下面还有一些子接口， Set、Seq、Map
这几个子接口下面有具体的实现类

set下面有HashSet、LinkedHashSet、SortedSet等等
seq下面有List、Buffer、Range等等
Map下面有HashMap、SortedMap、LinkedHashMap等等
其中Buffer下面还有两个常用的，ArrayBuffer、ListBuffer

这是集合中一些常见的实现类

在讲这个集合体系的时候，还会关联讲到Array和Tuple这两个数据结构

集合

Scala中的集合是分成可变和不可变两类集合的

其中可变集合就是说，集合的元素可以动态修改
而不可变集合就是说，集合的元素在初始化之后，就无法修改了

可变集合: 在scala.collection.mutable 这个包下面
不可变集合: 在scala.collection.immutable 这个包下面

我们在创建集合的时候，如果不指定具体的包名，默认会使用不可变集合

Set

先来看一下Set，Set代表一个没有重复元素的集合
这个集合的特性和Java中Set集合的特性基本一样
Set集合分为可变的和不可变的集合，默认情况下使用的是不可变集合

Set可以直接使用，并且不需要使用new关键字，来看一下

scala> val s = Set(1,2,3)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

注意:默认情况下直接创建的set集合是一个不可变集合，在这可以看到是在immutable包里面的，不可变集合中的元素一经初始化，就不能改变了，所以初始化后再向里面添加元素就报错了。

scala> val s = Set(1,2,3)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)scala> s += 4
<console>:9: error: value += is not a member of scala.collection.immutable.Sets += 4 ^

但是注意，我使用s + 4 这种操作是可以的

scala> val s = Set(1,2,3)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)scala> s + 4
res33: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

s + 4 返回的是一个新的集合了，相当于在之前的集合的基础上，创建一个新的集合，新的集合包含之前集合的元素和我们新增的4这个元素

如果想要创建一个可变的set集合，可以使用mutable包下面的set集合，显式指定包名

scala> val s = scala.collection.mutable.Set(1,2,3)
s: scala.collection.mutable.Set[Int] = Set(1, 2, 3)scala> s += 4
res34: s.type = Set(1, 2, 3, 4)

Set常用子类有: HashSet、LinkedHashSet、SortedSet

HashSet:这个集合的特点是:集合中的元素不重复、无序
LinkedHashSet:这个集合的特点是:集合中的元素不重复、有序，它会用一个链表维护插入顺序，可以保证集合中元素是有序的
SortedSet:这个集合的特点是:集合中的元素不重复、有序，它会自动根据元素来进行排序

演示一下:

先看HashSet
HashSet集合分为可变和不可变之分， immutable 包下面的是不可变的，后期无法新增元素
在这里可以使用new关键字，也可以不使用，因为HashSet既是class，又是object，但是包名需要指定，否则无法识别

scala> val s = new scala.collection.mutable.HashSet[Int]()
s: scala.collection.mutable.HashSet[Int] = Set()scala> s +=1
res35: s.type = Set(1)scala> s +=2
res36: s.type = Set(1, 2)scala> s +=5
res38: s.type = Set(1, 5, 2)

如果在创建集合的时候就初始化了元素，则可以省略泛型的定义，集合会自动识别元素的类型

再来看一下LinkedHashSet
LinkedHashSet只有可变的，没有不可变的

scala> val s = new scala.collection.mutable.LinkedHashSet[Int]()
s: scala.collection.mutable.LinkedHashSet[Int] = Set()scala> s +=1
res42: s.type = Set(1)scala> s +=2
res43: s.type = Set(1, 2)scala> s +=5
res44: s.type = Set(1, 2, 5)

最后来看一下SortedSet
SortedSet分为可变集合和不可变集合

scala> val s = scala.collection.mutable.SortedSet[String]()
s: scala.collection.mutable.SortedSet[String] = TreeSet()scala> s +=("c")
res45: s.type = TreeSet(c)scala> s +=("a")
res46: s.type = TreeSet(a, c)scala> s +=("b")
res47: s.type = TreeSet(a, b, c)

从这可以看出来SortedSet集合中的元素是按照元素的字典顺序排序的

针对里面这些Set集合，如果想要迭代他们里面的元素，可以使用for循环直接迭代
以SortedSet为例，其它的 Set、HashSet、LinkedHashSet 都是一样的

scala> for(i <- s ) println(i)
a
b
c

List

接下来看一下List，List属于Seq接口的子接口
List代表一个不可变的列表
创建一个list

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

针对List有 head 、 tail 以及 :: 这几个操作
先演示一下 head、tail 操作

scala> l.head
res49: Int = 1
scala> l.tail
res51: List[Int] = List(2, 3, 4)

head:表示获取List中的第一个元素
tail:表示获取List中第一个元素之后的所有元素

那其实head和tail就可以获取list中的所有元素了

通过 :: 操作符，可以将head和tail的结果合并成一个List

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

针对List中的元素进行迭代和前面讲的Set集合的迭代是一样的

scala> val l = List(1, 2, 3, 4)
l: List[Int] = List(1, 2, 3, 4)
scala> for(i <- l) println(i)
1
2
3
4

在这里List是不可变的列表，在实际工作中使用的时候会很不方便，因为我们很多场景下都是需要向列表中动态添加元素，这个时候该怎么办呢?

Scala还提供的有一个ListBuffer

ListBuffer:可以支持动态增加或者移除元素

scala> val lb = scala.collection.mutable.ListBuffer[Int]()
lb: scala.collection.mutable.ListBuffer[Int] = ListBuffer()scala> lb +=1
res56: lb.type = ListBuffer(1)scala> lb +=2
res57: lb.type = ListBuffer(1, 2)scala> lb +=5
res58: lb.type = ListBuffer(1, 2, 5)scala> lb -=5
res59: lb.type = ListBuffer(1, 2)

ListBuffer也可以直接使用for循环迭代

scala> for(i <- lb) println(i)
1
2

Map

Map是一种可迭代的键值对(key/value)结构

创建一个不可变的Map

scala> val ages = Map("jack"->30,"tom"->25,"jessic"->23)
ages: scala.collection.immutable.Map[String,Int] = Map(jack -> 30, tom -> 25, jessic -> 23)scala> ages("jack")
res100: Int = 30

创建一个可变的Map

scala> val ages = scala.collection.mutable.Map("jack"->30,"tom"->25,"jessic"->23)
ages: scala.collection.mutable.Map[String,Int] = Map(jessic -> 23, jack -> 30, tom -> 25)scala> ages("jack")
res101: Int = 30

还有一种创建Map的简易方式，这种方式创建的是不可变Map

scala> val ages = Map(("jack",30),("tom",25),("jessic"->23))
ages: scala.collection.immutable.Map[String,Int] = Map(jack -> 30, tom -> 25, jessic -> 23)

查询操作
获取指定key对应的value，如果key不存在，会报错

scala> val ages = scala.collection.mutable.Map(("jack",30),("tom",25),("jessic"->23))
ages: scala.collection.mutable.Map[String,Int] = Map(jessic -> 23, jack -> 30, tom -> 25)scala> val age = ages("jack")
age: Int = 30scala> val age = ages("jack1")
java.util.NoSuchElementException: key not found: jack1

所以在实际工作中这样直接获取不太好，如果遇到了不存在的key程序会报错，导致程序异常退出。那是不是可以考虑在获取key的值之前，先判断key是否存在
可以使用contains函数检查key是否存在、使用if-else语句，如果指定的key不存在，则返回一个默认值

scala> val age = if (ages.contains("jack1")) ages("jack1") else 0
age: Int = 0

这样是没问题的，就是写起来有点麻烦了，有没有方便一点的用法呢? map中还有一个getOrElse函数

scala> val age = ages.getOrElse("jack1", 0)
age: Int = 0scala> val age = ages.getOrElse("jack", 0)
age: Int = 30

建议后期从map中获取数据都使用这个 getOrElse 函数

修改
更新map中的元素

scala> ages("jack") = 31
scala> ages
res104: scala.collection.mutable.Map[String,Int] = Map(jessic -> 23, jack -> 31, tom -> 25)

增加多个元素

scala> ages += ("hehe" -> 35, "haha" -> 40)
res105: ages.type = Map(hehe -> 35, jessic -> 23, jack -> 31, tom -> 25, haha -> 40)

移除元素

scala> ages -= "hehe"
res106: ages.type = Map(jessic -> 23, jack -> 31, tom -> 25, haha -> 40)

遍历
遍历map的entrySet

scala> for ((key, value) <- ages) println(key + " " + value)
jessic 23
jack 31
tom 25
haha 40

遍历map的key

scala> for (key <- ages.keySet) println(key)
jessic
jack
tom
haha

遍历map的value

scala> for (value <- ages.values) println(value)
23
31
25
40

最后看一下Map的几个子类: HashMap、SortedMap和LinkedHashMap

HashMap:是一个按照key的hash值进行排列存储的map
SortedMap:可以自动对Map中的key进行排序【有序的map】
LinkedHashMap:可以记住插入的key-value的顺序

HashMap分为可变和不可变的，没有什么特殊之处
在这主要演示一下SortedMap和LinkedHashMap
SortedMap是不可变的

scala> val ages = scala.collection.immutable.SortedMap("b" -> 30, "a" -> 15, "c" -> 25)
ages: scala.collection.immutable.SortedMap[String,Int] = Map(a -> 15, b -> 30, c -> 25)

LinkedHashMap是可变的

scala> val ages = new scala.collection.mutable.LinkedHashMap[String, Int]()
ages: scala.collection.mutable.LinkedHashMap[String,Int] = Map()
scala> ages("b")=30
scala> ages("a")=15
scala> ages("c")=25
scala> ages
res116: scala.collection.mutable.LinkedHashMap[String,Int] = Map(b -> 30, a -> 15, c -> 25)

Array

Scala中Array的含义与Java中的数组类似，长度不可变
由于Scala和Java都是运行在JVM中，双方可以互相调用，因此Scala数组的底层实际上就是Java数组
数组初始化后，长度就固定下来了，而且元素全部根据其类型进行初始化

scala> val a = new Array[Int](10)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)scala> a(0)
res65: Int = 0scala> a(0)=1scala> a(0)
res67: Int = 1

也可以直接使用Array()创建数组，元素类型自动推断

scala> val a = Array("hello", "world")scala> a(0)
res68: String = helloscala> val a1 = Array("hello", 30)
a1: Array[Any] = Array(hello, 30)

如果想使用一个长度可变的数组，就需要使用到ArrayBuffer了

ArrayBuffer

Scala中ArrayBuffer与Java中的ArrayList类似，长度可变
ArrayBuffer:添加元素、移除元素
如果不想每次都使用全限定名，则可以预先导入ArrayBuffer类

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

初始化
使用ArrayBuffer()的方式可以创建一个空的ArrayBuffer

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

添加元素
使用+=操作符，可以添加一个元素，或者多个元素
b += 1 或者 b += (2, 3, 4, 5)

scala> b += 1
res69: b.type = ArrayBuffer(1)scala> b += (2, 3, 4, 5)
res70: b.type = ArrayBuffer(1, 2, 3, 4, 5)

使用insert()函数可以在指定位置插入元素，但是这种操作效率很低，因为需要移动指定位置后的所有元素
向3号角标的位置添加一个元素 30

scala> b.insert(3,30)
scala> b
res72: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 30, 4, 5）

移除元素
使用 remove() 函数可以移除指定位置的元素

scala> b.remove(1)
res73: Int = 2scala> b
res74: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 30, 4, 5)

注意:Array与ArrayBuffer可以互相进行转换

b.toArray:ArrayBuffer转Array
a.toBuffer:Array转ArrayBuffer

数组常见操作

下面看一下针对数据的常见操作

遍历Array和ArrayBuffer的两种方式
由于Array和ArrayBuffer都是有角标的，所以在迭代数组中元素的时候除了可以使用前面迭代集合的方式还可以使用角标迭代

scala> val b=ArrayBuffer(1, 2, 3, 4, 5)
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)
scala>  for(i <- b) println(i)
1
2
3
4 5
scala> for(i <- 0 until b.length ) println(b(i))
1
2
3
4
5

求和、求最大值

scala> val a = Array(3, 2, 1, 4, 5)
a: Array[Int] = Array(3, 2, 1, 4, 5)scala> val sum = a.sum
sum: Int = 15scala> val max = a.max
max: Int = 5

数组排序

scala> scala.util.Sorting.quickSort(a)
a: Array[Int] = Array(1, 2, 3, 4, 5)scala> a
res99: Array[Int] = Array(1, 2, 3, 4, 5)

Tuple

Tuple:称之为元组，它与Array类似，都是不可变的，但与数组不同的是元组可以包含不同类型的元素 Tuple中的元素角标从 1 开始

注意:目前 Scala 支持的元组最大长度为 22 ，对于更大长度可以使用集合或数组

scala> val t = (1, 3.14, "hehe")
t: (Int, Double, String) = (1,3.14,hehe)scala> t._1
res117: Int = 1scala> t._3
res118: String = hehe

总结

前面讲了很多集合体系中的数据结构，有的是可变的，有的是不可变的，有的是既是可变的又是不可变的，听起来有点乱，在这里我们总结一下:

可变集合: LinkedHashSet、ListBuffer、ArrayBuffer、LinkedHashMap
不可变集合: List、SortedMap
可变+不可变集合: Set、HashSet、SortedSet、Map、HashMap

还有两个编外人员: Array、Tuple

Array:长度不可变，里面的元素可变
Tuple:长度不可变，里面的元素也不可变