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不考虑泛型