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

集合