《Scala 4》--Scala的集合操作大全

集合操作：

 def ++[B](that: GenTraversableOnce[B]): Array[B]           【++】
    合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。
        
         val a = Array(1,2,3)
         val b = Array(3,4,5)
         val c = a ++ b
         print(c)
         print(c.toList)   //c中的内容是(1,2,3,3,4,5)
        类型返回已左侧为准！！   
         val a = List(1,2,3)
         val b = Array(3,4,5)
         val c = a ++ b

         val a = Array(1,2,3)
         val b = List(3,4,5)
         val c = a ++ b
    --------------------------------------------------------------------------------------------------------------------------------------
    def ++: [B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That     【++:】
    这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型。
     
        val a = Array(1,2,3)
        val b = List(3,4,5)
        val c = a ++: b
        print(c) 
        println(c.getClass().getName()) 
    --------------------------------------------------------------------------------------------------------------------------------------
    def +:(elem: A): Array[A]        【+：】
        +:  在数组前面添加一个元素，并返回新的对象，下面添加一个元素 0，，，数组在运算符的右边
        val a = List(1,2)
        val c = 0 +: a // c中的内容是 （0,1,2）
    --------------------------------------------------------------------------------------------------------------------------------------
    def :+(elem: A): Array[A]        【  :+ 】
        同上面的方法相似，在数组末尾添加一个元素，并返回新对象，，，数组在运算符的左边
        val a = List(1,2)
        val c = a :+ 0
        print(c)
    --------------------------------------------------------------------------------------------------------------------------------------
    def addString(b: StringBuilder): StringBuilder
    
        val a = List(1,2,3,4)
        val b = new StringBuilder()  // 带参数的字符串 val b = new StringBuilder("abc")
        val c = a.addString(b)      //将数组中的元素逐个添加到b中  c中的内容是  1234
    --------------------------------------------------------------------------------------------------------------------------------------
    def addString(b: StringBuilder, sep: String): StringBuilder
    同上，每个元素用sep分隔符分开
        val a = List(1,2,3,4)
        val b = new StringBuilder()
        val c = a.addString(b,",")
        println("c:  "+c)  // c:  1,2,3,4
    --------------------------------------------------------------------------------------------------------------------------------------
    def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
    同上，在首尾各加一个字符串，并指定sep分隔符
        val a = List(1,2,3,4)
        val b = new StringBuilder()
        val c = a.addString(b,"{",",","}")
        println("c:  "+c)  // c:  {1,2,3,4}
    --------------------------------------------------------------------------------------------------------------------------------------
    def mkString: String
    将所有元素组合成一个字符串
        val a = Array(1, 2, 3, 4, 5)
        println(a.mkString) // return  12345
    **************************************************************************************************************************************
    def mkString(sep: String): String
    将所有元素组合成一个字符串，以 sep 作为元素间的分隔符
        val a = Array(1, 2, 3, 4, 5)
        println(a.mkString(","))    // return  1,2,3,4,5
    **************************************************************************************************************************************
    def mkString(start: String, sep: String, end: String): String
    将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾
        val a = Array(1, 2, 3, 4, 5)
        println(a.mkString("{",",","}"))    // return  {1,2,3,4,5}
**************************************************************************************************************************************
    【柯里化】：并不是指这个函数，而是这个函数具有柯里化的特征
    def aggregate[B](z: => B)(seqop: (B, T) => B, combop: (B, B) => B): B
          聚合计算，aggregate是柯里化方法，参数是两个方法，
    为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。
      def main(args: Array[String]) {
        val a = List(1,2,3,4)
        val c = a.par.aggregate(5)(seqno,combine)   //val c = a.aggregate(5)(seqno,combine)
        println("c:"+c)
      }
      def seqno(m:Int,n:Int): Int ={
        val s = "seq_exp=%d+%d"
        println(s.format(m,n))
        return m+n
      }
      def combine(m:Int,n:Int): Int ={
        val s = "com_exp=%d+%d"
        println(s.format(m,n))
        return m+n
      }
      /**  多次运行结果演示,并行度是变化的
        seq_exp=5+3
        seq_exp=5+2
        seq_exp=5+4
        seq_exp=5+1
        com_exp=6+7
        com_exp=8+9
        com_exp=13+17
        c:30
      */
    上面过程可以简写为
    val c = a.par.aggregate(5)(_+_,_+_)
       
    根据CPU核数，多次运行结果会不一样25  或  30 
    
    --------------------------------------------------------------------------------------------------------------------------------------
    取出指定索引处的元素：        【像数组一样，用下标索引】
     val numbers = List(1,2,3,4)
     val first = numbers(0) // 读取第一个元素
     println("first:"+first)
    --------------------------------------------------------------------------------------------------------------------------------------
     def charAt(index: Int): Char
             获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，                                           只有当T为char类型时，这个转换才会发生。
     val chars = Array('a','b','c')
     println("c:"+chars.charAt(0))   //结果 a
    --------------------------------------------------------------------------------------------------------------------------------------
    def clone(): Array[T]
    创建一个副本
    val chars = Array('a','b','c')
    val newchars = chars.clone()
    println("newchars:"+newchars.toList)
    --------------------------------------------------------------------------------------------------------------------------------------
    def collect[B](pf: PartialFunction[A, B]): Array[B]
    通过执行一个并行计算（偏函数），得到一个新的数组对象
       val chars = Array('a','b','c')
       val newchars = chars.collect(fun)
       println("newchars:"+newchars.mkString(","))
      //我们通过下面的偏函数，把chars数组的小写a转换为大写的A
      val fun:PartialFunction[Char,Char] = {
        case 'a' => 'A'
        case x => x
      }
      /**输出结果是 newchars:A,b,c */
    --------------------------------------------------------------------------------------------------------------------------------------
    def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
    在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
     val arr = Array(1,'a',"b")
    //定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，对于上面定义的对象arr来说，只有第一个元素符合要求
      val fun:PartialFunction[Any,Int] = {
        case x:Int => x*100
      }
    //计算
      val value = arr.collectFirst(fun)
      println("value:"+value)
    //另一种写法
      val value = arr.collectFirst({case x:Int => x*100})
    
    --------------------------------------------------------------------------------------------------------------------------------------
    def map[B](f: (A) => B): Array[B]
    val a = List(1, 2, 3,4)
    println(a.map(x=>x))

    
    val a = List(List(1, 2), List(3,4))
    println(a.map(x=>x)) 
    println(a.map(x => x.sum))
    

    val lines=List("hello tom hello jerry","hello tom hello kitty hello china")    
    lines.map(_.split(" "))
    拿到每一个元素(字符串)，按照空格切割，切割后返回两个数组，仍放在List中
    res0: List[Array[String]] = List(Array(hello, tom, hello, jerry), Array(hello, tom, hello, kitty, hello, china))

    --------------------------------------------------------------------------------------------------------------------------------------
    def flatten[U](implicit asTrav: (T) => collection.Traversable[U], m: ClassTag[U]): Array[U]
    将二维数组的所有元素联合在一起，形成一个一维数组返回
    val dArr = Array(Array(1,2,3),Array(4,5,6))
    val c = dArr.flatten
    println(c)  
    -------------------------------------------------------------------------------                                                                                                            flatMap：
    flatMap=map+flatten
    map把每个元素都做一个相同的操作，flatten是把嵌套的变成在同一个里面，
    如val f = List(List(1,2),List(3,4),List(5,6)) 执行 f.flatten的结果就是List(1,2,3,4,5,6)
    所以f.flatMap(_.map(*2))的结果是List(2,4,6,8,10,12)相当于f.map(_.map(*2)).flatten，是先执行map，再执行flatten
 
 
    val lines=List("hello tom hello jerry","hello tom hello kitty hello china