Scala(三)：集合简介

一、Scala集合简介

scala同时支持不可变集合和可变集合。不可变集合（不能动态变化）位于scala.collection.immutable包下；可变集合（能动态变化）位于 scala.collection.mutable包下。scala默认采用不可变集合，对于几乎所有的集合类，scala都同时提供了可变和不可变的版本。

scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。

不可变集和继承图：

可变集和继承图：

二、元组

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组，最大的特点灵活,对数据没有过多的约束。

注意：元组中最大只能有22个元素

元组的创建：

    val tuple = (1,2,3,"hello")
    println(tuple)//(1,2,3,hello)
    val tuple2 = 2 -> "two"
    println(tuple2)//(2,two)
    val tuple3 = 3 -> "three" -> "三"
    println(tuple3)((3,three),三)

元组数据的访问：

访问元组中的数据,可以采用顺序号（_顺序号），也可以通过索引（productElement）访问。

    val tuple = (1,2,3,"hello")

    println(tuple._1)//1
    println(tuple.productElement(0))//1
	
	/*
	* 遍历
	*/
	for (item <- tuple.productIterator){
      println(item)
    }

三、数组

3.1不可变数组

定义：
第一种：

    //声明、赋值
    val arr = new Array[Int](10)
    arr(0)=10

第二种：

    //通过apply方法创建Array数组并赋值
    val arr: Array[Int] = Array(1, 2, 3, 4)

常见操作：

    //访问数组
    println(arr(0))

    //数组长度
    println(arr.length)

    //打印数组
    // 1、普通for循环
    for (int <- arr) {
      println(int)
    }
    //2、foreach
    arr.foreach((int) => {
      println(int)
    })
	//3、foreach最简形式
    arr.foreach(println(_))	
	
	//修改某个位置的值
	arr.update(2,5)

3.2 可变数组

    //通过apply()函数创建
    val arr = ArrayBuffer(1,2,3)
    //通过new创建对象
    val arr2 = new ArrayBuffer[Int](10)
    //添加元素
    arr2.append(1,2)

说明：

• ArrayBuffer是变长数组，类似Java的ArrayList
• def append(elems: A*) { appendAll(elems) }接收的是可变参数
• 每append一次，arr在底层会重新分配空间进行扩容，arr的内存地址会发生变化，也就成为新的ArrayBuffer

定长数组与变长数组的转换：

val arr3 = arr1.toBuffer：定长数组转可变数组
var arr4 = arr2.toArray：可变数组转定长数组

3.3 多维数组

/**
* arr 是一个二维数组
* 有三个元素[一维数组]
* 每个一维数组存放4个值
*/
val arr = Array.ofDim[Double](3,4)

//赋值
arr(1)(1) = 11.11

3.4 Scala数组与Java数组的互转

    /**
     * Buffer ==> java.util.List
     */
    val arr = ArrayBuffer("1", "2", "3")
    println(arr)// ArrayBuffer(1, 2, 3)
    import scala.collection.JavaConversions.bufferAsJavaList
    val javaArr = new ProcessBuilder(arr)
    val arrList = javaArr.command()
    println(arrList)// [1, 2, 3]


    /**
     * java.util.List ==> Buffer
     */
    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable
    val scalaArr: mutable.Buffer[String] = arrList
    println(scalaArr)// ArrayBuffer(1, 2, 3)

四、Seq

4.1 List

scala中的List和Java List不一样，在Java中List是一个接口，真正存放数据是ArrayList，而scala的List可以直接存放数据，就是一个object，默认情况下scala的List是不可变的，List属于序列Seq。

创建List：

    val list = List(1, 2, 3) //创建数组并初始化
    println(list)
    val list2 = Nil //创建空数组
    println(list2)

说明：

• List在scala包对象声明的,因此不需要引入其它包也可以使用
• List中可以放任何数据类型，比如arr1的类型为List[Any]
• 如果希望得到一个空列表，可以使用Nil对象

常见使用：

    val list = List(1, 2, 3) //创建数组并初始化
    //查看指定元素
    println(list(0))//1
    //元素的追加
    val list3 = list.:+(4)//或简写成list:+ 4
    println(list)//List(1, 2, 3)
    println(list3)//List(1, 2, 3, 4)

    /**
     * 符号::表示向集合中  新建集合添加元素
     * 运算时，集合对象一定要放置在最右边
     * 运算规则，从右向左
     * ::: 运算符是将集合中的每一个元素加入到空集合中去
     */
    val list5 = 4 :: 5 :: 6 :: list :: Nil // 从右向左的逻辑
     println(list5)//List(4, 5, 6, List(1, 2, 3))
    val list7 = 4 :: 5 :: 6 :: list ::: Nil
    println(list7)//List(4, 5, 6, 1, 2, 3)

ListBuffer

ListBuffer是可变的List集合，可以添加、删除元素，ListBuffer属于Seq序列。

    val listBuffer = ListBuffer(1,2,3)
    println(listBuffer)//ListBuffer(1, 2, 3)

4.2 Queue

说明：

• 队列是一个有序列表，在底层可以用数组或是链表来实现
• 其输入和输出要遵循先入先出的原则
• 在scala中， 有scala.collection.mutable.Queue和scala.collection.immutable.Queue，一般来说，我们在开发中通常使用可变集合中的队列

常用操作：

    /**
     * 创建Queue
     */
    import scala.collection.mutable
    val queue = new mutable.Queue[Int]()
	 /**
     * 追加
     */
//    queue +=1  //Queue(1)
    queue ++=List(1,2,3)//Queue(1, 2, 3)
	 /**
     * 入队出队
     */       
    queue.enqueue(4)//Queue(1, 2, 3, 4)
    queue.dequeue()//Queue(2, 3, 4)‘’
	 /**
     * 查看头尾信息
     */
    println(queue.head)//2
    println(queue.last)//4
    println(queue.tail)//Queue(3, 4)
    println(queue.tail.tail)//Queue(4)

五、Map

scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，不可变的Map(scala.collection.mutable.Map)是有序的，可变的Map(scala.collection.immutable.Map) 是无序的。

构造不可变Map：

scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型

    val map = Map("A" -> 1, "B" -> 2, "C" -> 3)
    println(map)//Map(A -> 1, B -> 2, C -> 3)

说明：

• 从输出的结果看到，输出顺序和声明顺序一致
• 构建Map集合中，集合中的元素其实是Tuple2类型
• 默认情况下（即没有引入其它包的情况下）,Map是不可变map

构造可变Map：

    val map2 = scala.collection.mutable.Map("A" -> 1, "B" -> 2, "C" -> 3)
    println(map2)//Map(A -> 1, C -> 3, B -> 2)

说明：

• 从输出的结果看到，输出顺序和声明顺序不一致

创建空的映射：

    val map3 = new scala.collection.mutable.HashMap[String, Int]
    println(map3)//Map()

对偶元组

对偶元组：只含有两个数据的元组

    val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )
    println("map4=" + map4)//map4=Map(D -> 30, A -> 1, C -> 3, B -> 2)
    println(map4("A"))//1

Map取值

① 使用map(key)
如果键存在, 返回对应的值对象；如果键不存在, 抛出异常。例：map("A")

② 使用contains方法检查是否存在key
例：map.contains("A")

③ map.get(key).get取值
通过映射.get(键)调用返回一个Option对象，要么是Some，要么是None，然后通过get函数返回。例：map.get("A").get

④ map4.getOrElse()取值
键不存在时提供默认值，例：map.getOrElse("D","defaultValue")

Map操作

	val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3) )
    //修改元素
    map4("A")=4
    //增加元素
    map4 +=("D" -> 4)
    //删除元素
    map4 -=("D")

    /**
     * 多种Map遍历方式
     */
    for ((k,v) <-map4){println(k+"->"+v)}//A->4	C->3	B->2
    for (v <-map4.keys){println(v)}//A C B
    for (v <-map4.values){println(v)}//4  3 2
    for (v <-map4){println(v)}//(A,4)	(C,3)	(B,2)

六、Set

集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。默认情况下，scala使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set包

创建：

    val set = Set(1,2,3)
    println(set)//Set(1, 2, 3)
    
    import scala.collection.mutable
    val mutableSet = mutable.Set(1,2,3)
    println(mutableSet)//Set(1, 2, 3)

常用操作：

    import scala.collection.mutable
    val mutableSet = mutable.Set(1, 2, 3)
	
	/* 添加元素 如果添加的对象已经存在，则不会重复添加，也不会报错 */
    mutableSet.add(4)
    mutableSet += 5
    mutableSet.+=(6)
    
	/* 删除元素 */
    mutableSet.remove(4)
    mutableSet -=4
    mutableSet.-=(4)

	/* 遍历元素 */
    for (i <- mutableSet){
      print(i+" ")
    }