Scala集合常用方法解析

 

Java 集合 : 數據的容器，可以在內部容納數據
 　　List : 有序，可重復的
　　 Set : 無序，不可重復
　　 Map : 無序，存儲K-V鍵值對，key不可重復

 scala 集合 ： 可變集合(ArrayList) & 不可變集合（數組）
　　 String(不可變字符串), （StringBuilder, StringBuffer)(可變字符串)

集合的基本方法

    val list: List[Int] = List(1,2,3,4)
    // 反轉集合
    //println(list.reverse) //List(6, 5, 4, 3, 2, 1)   //set，map沒有反轉
    list.max
    list.min
    list.sum //求和
    list.product //乘積

    // TODO 排序
    //val listStr = List("1", "5", "9", "11")
    //println("排序 = " + listStr.sorted) //排序 = List(1, 11, 5, 9) 按照字典順序；  數字、字符串都是按字符串的字典順序排序

    val stringList = List("11", "55", "13", "22")
    // 1, 5, 3, 2
    // 11 22 13 55
    // TODO 排序 使用自定義排序規則進行排序
    println(stringList.sortBy(x => {
      x.substring(1, 2)  //List(11, 22, 13, 55)
    }))
    //TODO 排序：升序，降序
    println("升序= " + stringList.sortWith{  //升序= List(11, 13, 22, 55)
      case (left, right) => {
        left < right
      }
    })
    println("降序= " + stringList.sortWith{  //降序= List(55, 22, 13, 11)
      case (left, right) => {
        left > right
      }
    })

TODO : 分組 groupBy(x=>{x%2})

 println("分組= " +list.groupBy(x => { 　　//分組= Map(1 -> List(1, 3, 5), 0 -> List(2, 4, 6))  x % 2 }))

聚合
Map 轉換，映射
// map方法將集合中的每一個元素進行轉換后放置到新的集合中

 println(list.map(_ * 2)) //List(2, 4, 6, 8, 10, 12) println(list.map((_, 1))) //List((1,1), (2,1), (3,1), (4,1), (5,1), (6,1))

 

 flatMap 扁平化  數->可迭代

（整體，拆成一個個的個體變成可迭代的集合）

 val list: List[Int] = List(1,2,3,4) 　　// TODO flatMap 扁平化 val list2 = List(List(1,2), List(3, 4), List(5, 6)) // ==> List(1,2,3,4,5,6) // in : List, out : Iterator println("扁平化=" + list2.flatMap(x => x)) //扁平化=List(1, 2, 3, 4, 5, 6) 集合中整體拆成一個個的 

 reduce 化簡，也稱歸約

 // TODO reduce 化簡 println(list.reduce((_ + _))) //10 兩兩聚合 println(list.reduce(_ - _)) //-8 println(list.reduceLeft(_ - _))//-8 同上，底層調用是一樣的 println(list.reduceRight(_ - _)) //-2 從右邊開始計算

fold　折疊foldLeft    foldRight 縮寫分別為 /： 和 ：\

scala中兩個map的合並 foldLeft

 val list: List[Int] = List(1,2,3,4) // TODO fold fold和reduce比較類似，僅僅是多了一個集合之后的初始值 println(list.fold(10)(_ - _)) // -0 底層本質上就是調用的foldLeft(z)(op) println(list.foldLeft(10)(_ - _)) //-0 // 1,2,3,4 ==> reverse ==> 4,3,2,1 // 底層運算時，將集合反轉后相鄰的元素交互調用邏輯 println(list.foldRight(0)(_ - _)) //-2 //reverse.foldLeft(z)((right, left) => op(left, right))

掃描 scanLeft 

掃描，即對某個集合的所有元素做fold操作，但是會把產生的所有中間結果放置於一個集合中保存

    def minus(num1: Int, num2: Int): Int = {
      num1 - num2
    }
    val i1 = (1 to 5).scanLeft(5)(minus) //1 2 3 4 5
                                       //5 4 2 -1 -5 -10
    println(i1)  //Vector(5, 4, 2, -1, -5, -10)

    def add( num1 : Int, num2 : Int ) : Int = {
      num1 + num2
    }
    val i2 = (1 to 5).scanLeft(5)(add) //1 2 3 4 5
                                     //5 6 8 11 15 20
    println(i2) //Vector(5, 6, 8, 11, 15, 20)

 

集合交Intersect、差diff、合union

    val lis1 = List(1,2,3,4)
    val lis2 = List(3,4,5,6,7)
    // 兩個集合合並
    println(lis1.union(lis2)) //List(1, 2, 3, 4, 3, 4, 5, 6, 7)
    // 兩個集合交集
    println(lis1.intersect(lis2)) //List(3, 4)
    // 兩個集合差集
    println(lis2.diff(lis1)) //List(5, 6, 7)


   

拉鏈，將兩個集合進行 對偶元組合並，可以使用拉鏈

 List1（1,2,3,4） List2（3,4,5,6,7） #多余的它會舍掉
println(lis1.zip(lis2)) //List((1,3), (2,4), (3,5), (4,6))

滑動窗口 sliding 

   // 滑動窗口window
    val intses: Iterator[List[Int]] = list.sliding(3)
    for (elem <- intses) {
      println(elem) //List(1, 2, 3)
                    //List(2, 3, 4)
    }

過濾filter   a.filter(_%2 == 0)

 // TODO 過濾 val a = List(1, 2, 3, 4) def test(i: Int): Boolean = { i % 2 == 0 } println("過濾=" + a.filter(test)) //簡化如下 println(a.filter(_ % 2 == 1))

 

wordcount

object TestWorldCount {
  def main(args: Array[String]): Unit = {
    // 數據
    val lines = List("Hello Atguigu", "Hello Scala", "Hello Hbase", "Hi Atguigu")
    // 將一行的數據進行分解，變成一個一個的單詞（扁平化）
    val words: List[String] = lines.flatMap(line => {line.split(" ")})
    // 將扁平化后的單詞進行分組
    val groupNameToWordMap: Map[String, List[String]] = words.groupBy(word=>word)
    // 將分組后的數據轉換為單詞和數量的結構  _1是單詞分組名稱; t._2是集合
    val wordToCountMap: Map[String, Int] = groupNameToWordMap.map(t=>{(t._1, t._2.size)})
    // 將轉換后的數據進行排序
    // map(k-v, k1-v1, k2-v2) ==> List((k,v), (k1,v1))
    val resultList: List[(String, Int)] = wordToCountMap.toList.sortWith {
      case (left, right) => {
        left._2 > right._2 //元組, 根據v去比較判斷
      }
    }
---------------簡化版-------------------------------
    val resultList: List[(String, Int)] = lines.flatMap(_.split(" ")).groupBy(word => word).map(t => {
      (t._1, t._2.size)
    }).toList.sortWith {
      case (left, right) => {
        left._2 > right._2
      }
    }
-----------------------------------------
    resultList

    resultList.foreach(println)
  }

}

 map中_1 key, _2 value

array考慮泛型，map的k,v不考慮泛型