Scala集合相关

        对scala中的集合类虽然有使用，但是一直处于一知半解的状态。尤其是与java中各种集合类的混合使用，虽然用过很多次，但是一直也没有做比较深入的了解与分析。正好趁着最近项目的需要，加上稍微有点时间，特意多花了一点时间对scala中的集合类做个详细的总结。

1、Scala集合

Scala中的集合类的框架大致如下：（网载图）

      Scala的集合有三大类：
序列Seq：Seq，是一组有序的元素。
集合Set： Set，是一组没有重复元素的集合。
映射Map：Map，是一组k-v对。

下面进行逐个介绍：

1.1 Seq

Seq主要由两部分组成：IndexedSeq与LinearSeq。现在我们简单看下这两种类型。
首先看IndexedSeq，很容易看出来这种类型的主要访问方式是通过索引，默认的实现方式为vector。

  def test() = {
    val x = IndexedSeq(1,2,3)
    println(x.getClass)
    println(x(0))
 
    val y = Range(1, 5)
    println(y)
  }

运行结果：
class scala.collection.immutable.Vector
1
Range(1, 2, 3, 4)

       而作为LinearSeq，主要的区别在于其被分为头与尾两部分。其中，头是容器内的第一个元素，尾是除了头元素以外剩余的其他所有元素。LinearSeq默认的实现是List

  def test() = {
    val x = collection.immutable.LinearSeq("a", "b", "c")
    val head = x.head
    println(s"head is: $head")
 
    val y = x.tail
    println(s"tail of y is: $y")
  }

运行结果：
head is: a
tail of y is: List(b, c)

1.2 Set

与其他任何一种编程语言一样，Scala中的Set集合类具有如下特点：
1.Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
2.Scala 集合分为可变的和不可变的集合。默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。
默认引用 scala.collection.immutable.Set，不可变集合实例如下：
Scala中的集合分为可变与不可变两种，对于Set类型自然也是如此。先来看看示例代码：

不可变类型，所以所有语句结果其实都是生成一个新的集。
  def test() = {
    val x = immutable.HashSet[String]("a","c","b")
    //x.add("d")无法使用，因为是不可变集合，没有add方法。
    val y = x + "d" + "f"  // 增加新的元素，生成一个新的集合
    val z = y - "a"  // 删除一个元素，生成一个新的集合
    val a = Set(1,2,3)
    val b = Set(1,4,5)
    val c = a ++ b  // 生成一个新的集合，增加集合
    val d = a -- b  // 生成一个新的集合，去除集合
    val e = a & b // 与操作
    val f = a | b // 或操作
  }

可变类型，在原集合的基础上对集合进行操作。
  def test() = {
    val x = new mutable.HashSet[String]()
    x += "a"  // 添加一个新的元素。注意此时没有生成一个新的集合
    x.add("d") //因为是可变集合，所以有add方法
    x ++= Set("b", "c")  // 添加一个新的集合
    x.foreach(each => println(each))
    x -= "b"  // 删除一个元素
    println()
    x.foreach(each => println(each))
    println()
    val flag = x.contains("a") // 是否包含元素
    println(flag)
  }

输出结果：
c
d
a
b
 
c
d
a
 
true

1.3 Map

       Map这种数据结构是日常开发中使用非常频繁的一种数据结构。Map作为一个存储键值对的容器（key－value），其中key值必须是唯一的。 默认情况下，我们可以通过Map直接创建一个不可变的Map容器对象，这时候容器中的内容是不能改变的。示例代码如下。

  def test() = {
    val peoples = Map("john" -> 19, "Tracy" -> 18, "Lily" -> 20) //不可变
    // people.put("lucy",15) 会出错，因为是不可变集合。
    //遍历方式1
    for(p <- peoples) {
      print(p + "  ") // (john,19)  (Tracy,18)  (Lily,20)
    }
    //遍历方式2
    peoples.foreach(x => {val (k, v) = x; print(k + ":" + v + "  ")}) //john:19  Tracy:18  Lily:20
    //遍历方式3
    peoples.foreach ({ case(k, v) => print(s"key: $k, value: $v  ")})
    //key: john, value: 19  key: Tracy, value: 18  key: Lily, value: 20
  }

上面代码中的hashMap是不可变类型。
如果要使用可变类型的map，可以使用mutable包中的map相关类。

  def test() = {
    val map = new mutable.HashMap[String, Int]()
    map.put("john", 19) // 因为是可变集合，所以可以put
    map.put("Tracy", 18)
    map.contains("Lily") //false
    val res = getSome(map.get("john"))
    println(res) //Some(19)
  }
 
  def getSome(x:Option[Int]) : Any = {
    x match {
      case Some(s) => s
      case None => "None"
    }
  }