2scala集合

1、集合的数据结构：

　　　　array、seq 、set 、map（映射）

2、集合分类

　　集合分为可变集合和不可变集合（除元组外，元组没有可变和不可变）

　　scala.collection.immutable : 不可变集合的包
　　scala.collection.mutable : 可变集合的包

3、集合初始化

    不可变集合：

        val s=  Array[Int](10)                
        val s = Array[String]("Hello","World")

        val s = List[Int](1, 2, 3, 4)
        val s = Set[Int](1,2,4)

        val s = Map("Ali" -> 10, "Bob" -> 3, "City" -> 8);
        val s = Map(("Ali", 10),  ("Bob", 3),  ("City", 8));

    可变集合：

        val b = scala.collection.mutable.ArrayBuffer[Int]()

        val b = scala.collection.mutable.ListBuffer[Int](1, 2, 3, 4)
        val b = scala.collection.mutable.Set(1,2,3)

        val b = scala.collection.mutable.Map[String,Int]()                        
        val b = scala.collection.mutable.Map("Ali" -> 10, "Bob" -> 3, "City" -> 8)


    注：系统默认是不可变集合，如果是可变，必须前面加包名

4、集合的公共操作

　4.1、迭代（遍历）

　　　　　　一共三种方法：iterator、for、foreach

        val coll= . . .                     　　 　　　　　　　　//coll是一个集合、            
        val iter = coll.iterator 
        while (iter.hasNext) {
             iter . next （）
        }

        for (elem <- coll) {    }                　　　　　　　　//如果是map,则应该： for (（k,v） <-  coll) {   }

        List(1,2,3).iterator.foreach( println(_) )            //foreach 是Iterator上的方法

　4.2、转化

    　　 val coll= . . .                     //集合都是可以互相转化的
        coll.toSeq            　　　　　　
        coll.toSet
        coll.toMap
        coll.toArray                        //转化为不可变数组Array
        coll.toBuffer                        //转化为可变数组ArrayBuffer

　4.3、增删（++，- -）

    　　 val list  = List(1, 2, 3, 4)                    //以list举例，其余的都可以    
        val list2 = list ++ list
        
        注：不可变集合通过将结果赋值给另一个变量实现增，但是不能实现删



　　　　　val listBuffer = scala.collection.mutable.ListBuffer[Int](1, 2, 3, 4)    //以list举例，其余的都可以    
        
        listBuffer -= 4
        listBuffer += 4
        listBuffer ++= listBuffer                    //等价于listBuffer = listBuffer ++ listBuffer 
        listBuffer --= listBuffer                    //等价于listBuffer = listBuffer -- listBuffer 
        listBuffer = listBuffer ++ listBuffer
        注：++、--是操作的集合，+、-是针对某一元素

5、Iterable 特质的重要方法（所有）         

            sum | product | max | min               　　 　　　　　　　　//和，乘积，最大值，最小值


            head & last & headOption & lastOption           　　　　　　 //返回第（最后）一个元素，但是如果集合没有元素，head 会抛出异常，但是headOption会返回none
        
                eg ：      var coll = Map("A"->1, "B"->2, "C"->3)
                               coll.head                　　　　　　　　//(A,1)




            tail & init                        　　　　　　　　　　　　　　//返回除第（最后）一个的元素集合


            take(n) | drop(n) | splitAt()                // take(n) | drop(n) <==>takeLeft(n) | dropLeft(n)。返回前n个元素，除前n个的其他元素，两组对偶

                eg： var coll = Set(1, 2, 3, 4)
                    coll.take(2)                　　　　　  //Set(1, 2)
                    coll.drop(2)                　　　　　　//Set(3, 4)
                    coll.splitAt(2)                　　　　//(Set(1, 2),Set(3, 4))

            takeRight(n) | dropRight(n)                //返回最后n个元素，除最后n个的其他元素，两组对偶

            slice(from, to)                   　　　　 //返回位于从from开始到to结束这个区间内的所以元素

                eg：var coll = Set(1, 2, 3, 4)
                       coll.slice(0,2)                //Set(1, 2)

            grouped                        　　　　　　//将集合分为两个


                eg：val xs = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
                       xs.grouped(4).foreach(println)        //List(1, 2, 3, 4)，List(5, 6, 7, 8)，List(9)



            mkString(before,between,after)、addString(sb, before, between, after)        //转化为字符串

                eg : var coll = List("a", "b", "c")
                       coll.mkString("<","-",">")            //<a-b-c>        

                

            map(f) | foreach(f) | flatMap(f) | collect(pf)        //将函数f应用到所有元素

                注：flatMap和map的区别：

                val arr = ["a b","c d"]
                val arr2 = arr.flatMap (x => x.split(" ") ）    //扁平化：["a","b","c","d"]
                val arr3 = arr.map (x => x.split(" ") ）        //[["a","b"],["c","d"]]



            count(pred) | forall(pred) | exists(pred)            //返回满足时提前表达式的元素计数，所有元素满足时返回true，至少一个元素满足是返回true

                eg  :    var coll = Set(1, 2, 3, 4)

                    coll.count(_<3)            //2

            filter(pred) | filterNot(pred) | partition(pred)        //返回所有满足前提表达式的元素，所有不满足的元素,两组元素组成的对偶
            takeWhile(pred) | dropWhile(pred) | span(pred)        //和上面一样，只不过遇见第一个不满足，就不扫描了

                eg : 
                    var coll = Set(1, 3, 2)    
    
                    coll.filter(_<3)            //Set(1)
                    coll.takeWhile(_<3)            //Set(1, 2)

                    coll.partition(_<2)            //(Set(1,2),Set(3))
                    coll.span(_<2)            //(Set(1),Set(3, 2))

            reduceLeft 、reduceRight                 //reduceLeft <==> reduce。reduceLeft将结果作为左边参数,还有

                    (1 to 9) . reduceLeft( _  *  _)                //1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9
                    arr.reduceLeft((a,b) => if (a > b) a else b        //找出最大值
        

            foldLeft :                         //foldLeft <== > fold。其实和reduceLeft差不多，只不过增加了初始值
                    List (1, 7, 2, 9). foldLeft (0) (_  *  _)     //0*1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9

            zip(coll2) | zipAll(coll2,fill,fill2)                 //返回由本集合元素和另外一个集合的元素组成的对偶，当长度不一致时，进行填充

                    var coll = List("a", "b")
                    var coll2 = List(1, 2)
                    coll.zip(coll2)            //List(("a",1),("b",1))

            注：  coll.filter(_<3) 等价于coll.filter(x => x <3)
                  coll.filter(_+_)                    //_只是匹配参数，第二个_表示第二个参数，但是没有第二个参数，所以这写法是错误的，一般推荐第二种
                  coll.filter(x => x + x)                //把参数变为x,可以无限使用

6、Seq特质的重要方法（list、array）

            reverse                                //倒置序列
            contains(elem)、containsSlice(seq)、startsWith(seq)、endsWith(seq)        //返回true，如果该序列：包含给定元素、包含给定序列、以给定序列开始、以给定序列结束

            padTo(n,fill)                            //返回当前序列的一个拷贝，将fill的内容向后追加，直到新序列长度达到n
                eg:    val list2 = List(8,9)
                    val list = List(1,3,4,23,4,5)
                    list.padTo(5,list2)                    //List(1, 3, 4, 23, 4, 5)

            indexWhere（pred）                        //满足表达式的第一个元素索引
                eg :          val list = List(1,3,4,23,4,5,6,7,8,1,23)
                    list.indexWhere(_>20)                //3
            
            indexOf(elem)、lastIndexOf(elem)、indexOfSlice(seq)、lastIndexOfSlice(seq)    //返回给定元素或序列在当前序列中的首次或末次出现的下标

            intersect(seq)、diff(seq)                        //交集和序列之间的差异。

                eg :    val list2 = List(8,1,23,9)
                    val list = List(1,3,4,23,4,5)
                    list.intersect(list2)                    //List(1, 23)
                    list.diff(list2)                    //List(3, 4, 4, 5)    

            sorted, sortWith(less), sortBy(f)                     //默认排序，二元函数排序、自定义函数排序

                eg:         "Mary had a" . split (" ").sortWith(_. length< _.length)    //Array ("a ", "had","Mary")

7、线程安全的集合

    SynchronizedBuffer
    SynchronizedMap
    SynchronizedPriorityQueue
    SynchronizedQueue
    SynchronizedSet
    SynchronizedStack

　　    注：方法还是大同小异，只不过是线程安全，但是速度慢，一般都是用线程不安全的集合

8、List、set

            val set = Set(1,2,4)
            val set = scala.collection.mutable.Set(1,2,3）　　　　　　//初始化

            val list = List(1, 2, 3, 4)            
            val ListBuffer = scala.collection.mutable.ListBuffer[Int](1, 2, 3, 4)

            //List 增加了Nil（空表）、:: （等价于+:）、:::（等价于++：）的概念
            //::操作单个元素，:::操作集合

            val a= 9 : : List(4)                                  　　//a = List(9,4)    
            val a = 9 : : 4  : : Nil                             //最右边必须是集合，不能val a= 9 : : 4 : : 2，所以加空表

            val b = a ::: a        改写 ：val b = a ++: a               //但是不推荐改写
            
            //因为底层是链表，还增加了首尾增加元素，了解
            val a= 9 +: List(4, 2)                        //（9,4,2）
            var b = List(4, 2) :+ 9                        //（4,2,9）

9、数组

    ①不可变数组：Array
    —————————————————————————————————————————————————————————
        val s=  Array[Int](10)                
        val s = Array[String]("Hello","World")

        s(0) = "GoodBye"                     //改，推荐使用
    —————————————————————————————————————————————————————————
    ②可变数组：ArrayBuffer
    —————————————————————————————————————————————————————————
        val b = scala.collection.mutable.ArrayBuffer[Int]()

        b.insert(1, 6)                    //在下标为1的地方增加一个元素6
        b.remove(2);                    //移除下标为2的元素
        b.remove(2,2);                    //从下标为2的地方开始，移除两个元素
    
        注：因为数组有顺序，多了指定位置增删，insert，remove
    —————————————————————————————————————————————————————————
    ③常用方法：max、min、mkstring 、reverse
    —————————————————————————————————————————————————————————
           val arr = Array(1,2,3,4,5,6)
           println(arr.max)
           println(arr.min)
           println(arr.mkString)            //123456
           println(arr.mkString("|"))            //1|2|3|4|5|6
           println(arr.mkString("[", "|", "]"))        //[1|2|3|4|5|6]
           println(arr.reverse)                //Array(1,2,3,4,5,6)-->Array(6,5,4,3,2,1)

10、Map(映射)

    ①不可变映射：
    ——————————————————————————————————————————————————————————
        val s = Map("Ali" -> 10, "Bob" -> 3, "City" -> 8);        //初始化
        val s = Map(("Ali", 10),  ("Bob", 3),  ("City", 8));

        val aLi = s("Ali")
        val aLi = s.getOrElse("Ali",0)                //如果不存在返回0，推荐使用

        for (i <- map.keySet) {                //keyset、values方法
                 println(i);
            }

            map.values                    
    —————————————————————————————————————————————————————————
    ②可变映射
    —————————————————————————————————————————————————————————
        val s = scala.collection.mutable.Map[String,Int]()                        //初始化
        val s = scala.collection.mutable.Map("Ali" -> 10, "Bob" -> 3, "City" -> 8)
        
        s("Ali") = 10
    
        s += ("Dog" -> 12, "Esi" -> 10)                            //可变集合的增删举例        
        s - = "Ali" 
    —————————————————————————————————————————————————————————
    ③排序映射
    —————————————————————————————————————————————————————————
        val scores = scala .collection .mutable.SortedMap （”Alce " - > 10, ” Fred" - > 7, ” Bob” - > 3 ， ”Cndy” －＞ 8) 
        //默认会按字典排序，就是说你遍历时候，会按字典排序出来（字典排序：unicode的字符集的前后位置）

        val months = scala . collection .mutable.LinkedHashMap (” January" > 1, ” February ” -> 2, “. . . ) 
        //默认会按输入值的排序    

11、Tuple（元组）

    元组虽属于集合，但是以上的规律，增删都不适用。

    val t1 = ("小明", "男", 23)

        println(t1._1 + ":" + t1._2 + "-" + t1._3)

    val arr1 = Array("a", "b", "c")
       val arr2 = Array("A", "B", "C")

       val tuple = arr1 zip arr2            //拉链操作  ((a,A), (b,B), (c,C))