如何在 Scala 中科學地操作 collection

在日常項目開發中，我們幾乎都會用到Scala中的集合以及一些集合操作。由于 Scala 中的集合操作靈活多變，對于剛接觸Scala的開發者，在選用何種集合以及使用何種集合操作就顯得不那么合理了，雖然大部分時候都可以解決問題，但是有時候并沒有選擇最優的方式。科學合理地操作Scala中的集合可以使我們的代碼變得更加簡潔和高效。

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 類型。

 

 

來自：https://juejin.im/post/58d3421761ff4b006049417d