Scala 中的集合（一）：集合類型與操做

本文由 Shaw 發表在 ScalaCool 團隊博客。

Mutable 和 Immutable 集合

Scala 集合類系統地區分了可變的和不可變的集合。

scala.collection 包中全部的集合類

scala.collection.mutable 中的全部集合類

可變集合，顧名思義，意味着你能夠修改，移除或者添加一個元素。

scala.collection.immutable 中的全部集合類

不可變集合，相比可變集合，不可變集合永遠不會被改變，可是你仍然能夠像可變集合那樣操做（修改，添加，刪除某個集合元素）不可變集合，只是這些操做在每一種狀況下都是返回一個新的集合，同時，原來的集合不會發生改變，因爲此特性，不可變集合也是線程安全的，Scala在默認狀況下采用的是不可變集合。因此在使用上，優先使用不可變集合。不可變集合適用於大多數狀況。

不一樣集合的使用場景

其中經常使用的集合有三種：List，Set，Map。

列表 List

List 繼承至 Seq，集合中的元素是能夠重複的。

e.g.

scala> val l = List(1, 1, 2, 2, 3, 5)
l: List[Int] = List(1, 1, 2, 2, 3, 5)
複製代碼

因此當集合內的元素是可重複的時候，能夠選擇 List 或者 Seq。

集 Set

Set 中的元素是不可重複的。

e.g.

scala> val s = Set(1, 1, 2, 2, 3, 5)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 5)
複製代碼

因此當集合內的元素是不可重複的時候，選擇 Set。

映射 Map

Map 中的元素呈現 key -> value 的形式，其中第一個參數是映射的鍵，第二個參數是映射的值。且Map中每個元素的鍵是惟一的。

e.g.

scala> val m = Map(1 -> 1, 1 -> 3, 2 -> 3, 3 -> 4, 4 -> 4, 5 -> 7)
m: scala.collection.immutable.Map[Int,Int] = Map(5 -> 7, 1 -> 3, 2 -> 3, 3 -> 4, 4 -> 4)
複製代碼

因此當集合中的元素是 key -> value 的形式且每一個元素的鍵不重複的時候，選擇 Map。

集合中方法的使用

各集合操做之間的比較

在開始介紹不一樣方法的使用場景以前，咱們先對比一下不一樣方法操做同一集合所產出的結果有何異同。

• map、filter、collect 的比較

//定義一個列表
scala> val l = List(1, 2, 3, 4, 5)
l: List[Int] = List(1, 2, 3, 4, 5)

//map操做
scala> l.map(_ * 2)
res0: List[Int] = List(2, 4, 6, 8, 10)

//filter操做
scala> l.filter(_ > 2)
res3: List[Int] = List(3, 4, 5)

//collect操做
scala> l.collect {case i if i > 2 => i * 2}
res1: List[Int] = List(6, 8, 10)
複製代碼

經過以上結果對比咱們能夠看到：

map 操做獲得的集合，除了元素個數和原集合同樣，其餘都不同。

filter 操做獲得的集合是原集合的子集。

collect 操做獲得的集合雖然和原集合不同，可是仔細觀察，能夠看到 collect 操做獲得的結果是 map 操做獲得結果的子集，並且元素的個數和 filter 操做獲得的集合元素個數相同。

• flatten 和 flatMap 的比較

//定義一個列表
scala> val l = List(List(1, 2, 3), List(4, 5, 6), Seq(7, 8, 9))
l: List[Seq[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))

//flatten操做
scala> l.flatten
res5: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

//flatMap操做
scala> l.flatMap(i => i.map(_ * 2))
res6: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18)
複製代碼

經過以上結果咱們能夠看到，flatten 和 flatMap 均可能夠將嵌套結構扁平化爲一個層次的集合，可是：

flatten 僅僅是將嵌套結構扁平化了，並無改變原來集合內層列表中元素的值。

flatMap 不只將嵌套結構扁平化了，並且改變了原來集合內層列表中元素的值，其實 flatMap 就是在 flatten 以後再作一個 map 操做。

補充：以上操做返回的都是一個批量的結果，若是要查找某一特定元素，則能夠採用類比的方法：

filter -> find

collect -> collectFirst

不一樣方法的使用場景

經過以上對比，咱們對集合中經常使用方法的操做結果有了一個大體的認識，接下來咱們看看在不一樣場景下如何科學地選擇相應的集合操做。

咱們先定義一些將要在後面場景中使用的數據結構：

case class Student( name: String, age: Int, sex: String )
val jilen = Student(
  name = "Jilen",
  age = 30,
  sex = "m"
)
val shaw = Student(
  name = "Shaw",
  age = 18,
  sex = "m"
)
val yison = Student(
  name = "Yison",
  age = 40,
  sex = "f"
)
val l = List(jilen, shaw, yison)
l: List[Student] = List(Student(Jilen,30,m), Student(Shaw,18,m), Student(Yison,40,f))
複製代碼

如上，咱們定義了一個學生組成的列表。

場景一：咱們要獲得這些學生姓名所組成的列表

分析：學生姓名所組成的列表和原列表（學生列表）是不一樣的，是一個全新的列表，因此這裏選用 map

val nameList = l.map(_.name)
nameList: List[String] = List(Jilen, Shaw, Yison)
複製代碼

map 是對集合中的每一個元素應用一個函數，返回應用後的元素所組成的集合，一般狀況下，map所返回的集合和原集合是是不一樣類型的集合，也就是一個全新的集合。

場景二：咱們要獲得全部性別是男（m）的學生所組成的列表

分析：獲得的列表仍是學生列表，而且該列表是原列表的子集，由於有一個附加條件：男性學生，因此這裏選用 filter

val maleList = l.filter(_.sex == "m")
maleList: List[Student] = List(Student(Jilen,30,m), Student(Shaw,18,m))
複製代碼

filter 通常用於移除集合中不知足條件的元素，返回知足條件的元素所組成的集合。 固然，這裏用 collect 也能夠解決問題：

val maleList = l.collect{case s if s.sex == "m" => s}
maleList: List[Student] = List(Student(Jilen,30,m), Student(Shaw,18,m))
複製代碼

可是對比一下，能夠發現filter更加簡潔。

場景三： 咱們要獲得男學生姓名所組成的列表

分析：要獲得男學生姓名，咱們首先要獲得男學生，而後再去獲取這些學生的姓名，因此咱們很容易採用：

val maleNameList = l.filter(_.sex == "m").map(_.name)
maleNameList: List[String] = List(Jilen, Shaw)
複製代碼

可是經過咱們在以前各集合操做之間的比較中所得出的結論，因爲男學生姓名列表是一個和原列表（學生列表）徹底不一樣的，而且該列表是學生姓名列表的子集，因此咱們能夠採用 collect：

val maleNameList = l.collect{case s if s.sex == "m" => s.name}
maleNameList: List[String] = List(Jilen, Shaw)
複製代碼

獲得的結果和上面操做的結果同樣。

collect 接受的是一個偏函數，對集合中每一個元素應用該函數，返回應用後的元素所組成的列表，能夠將 collect 看做是先作 filter 操做再作 map 操做：

場景二中的 collect 操做能夠看做是：

l.filter(_.sex == "m").map(s => s)
List[Student] = List(Student(Jilen,30,m), Student(Shaw,18,m))
複製代碼

其餘經常使用方法

場景四：如今咱們要獲得每一個學生在列表中的位置以方便給他們編號

分析：咱們能夠採用 學生 -> 編號 的形式來組織學生與編號以前的關係，這裏咱們能夠採用 zipWithIndex：

l.zipWithIndex
List[(Student, Int)] = List((Student(Jilen,30,m),0), (Student(Shaw,18,m),1),(Student(Yison,40,f),2))
複製代碼

zipWithIndex 將能夠將集合內的元素與該元素在集合中的位置組合在一塊兒，其實就是將集合內的元素與該元素的位置組成了一個元組，元組的第二個值是元素在集合中所處的位置。

場景五：如今要將男學生和女學生分組，男學生組成一個集合，女學生組成一個集合

分析：根據場景的描述，新集合內的元素應該是：sex -> List[Student]的形式，這裏咱們能夠採用：groupBy：

val group = l.groupBy(_.sex)
group: scala.collection.immutable.Map[String,List[Student]] = Map(m -> List(Student(Jilen,30,m), Student(Shaw,18,m)), f -> List(Student(Yison,40,f)))
複製代碼

groupBy 就是對集合按照特定的要求進行分組，返回一個 Map類型。

延伸閱讀

Scala Collections Tips and Tricks

集合