【Scala】集合高级计算——过滤、map、扁平化、分组、reduce、折叠

一、介绍

（ 1 ）过滤

遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

（ 2 ） 转化 / 映射（ map ）

将集合中的每一个元素映射到某一个函数

（ 3 ）扁平化

（ 4 ）扁平化 + 映射 注： flatMap 相当于先进行 map 操作，在进行 flatten 操作集合中的每个元素的子元素映射到某个函数并返回新集合

（ 5 ） 分组 (group)

按照指定的规则对集合的元素进行分组

（ 6 ）简化（归约）

（ 7 ）折叠

二、实例

object TestList {
  def main(args: Array[String]): Unit = {
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val list1 = List(1,2,3,4)
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")

    //（1）过滤 ：筛选奇数或偶数
    println(list.filter(x => x % 2 == 0))

    //（2）转化/映射 ：+1操作
    println(list.map(x => x + 1))

    //（3）扁平化 ：将高维数据转为一维
    println(nestedList.flatten)

    //（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten 操作
    println(wordList.flatMap(x => x.split(" ")))

    //（5）分组 
    println(list.groupBy(x => x % 2))

    //（6）
    // reduce：将数据两两结合，实现运算规则
    val i: Int = list1.reduce( (x,y) => x-y )
    // 从源码的角度，reduce 底层调用的其实就是 reduceLeft
    //val i1 = list.reduceLeft((x,y) => x-y)
    // ((4-3)-2-1) = -2
    val i2 = list1.reduceRight((x,y) => x-y)

    //（7）
    // fold 方法使用了函数柯里化，存在两个参数列表
    // 第一个参数列表为 ： 零值（初始值）
    // 第二个参数列表为： 简化规则
    // fold 底层其实为 foldLeft
    val j = list1.foldLeft(1)((x,y)=>x-y)
    val j1 = list1.foldRight(10)((x,y)=>x-y)

    // 两个 Map 的数据合并
    val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
    val map2 = mutable.Map("a"->4, "b"->5, "d"->6)
    val map3: mutable.Map[String, Int] = map2.foldLeft(map1) {
      (map, kv) => {
        val k = kv._1
        val v = kv._2
        map(k) = map.getOrElse(k, 0) + v
        map
      }
    }

  }
}

 三、WordCount 案例

def main(args: Array[String]): Unit = {
    val stringList: List[String] = List(
      "hello",
      "hello world",
      "hello scala",
      "hello spark from scala",
      "hello flink from scala"
    )

    // 1. 对字符串进行切分，得到一个打散所有单词的列表
    //    val wordList1: List[Array[String]] = stringList.map(_.split(" "))
    //    val wordList2: List[String] = wordList1.flatten
    val wordList = stringList.flatMap(_.split(" "))
    println(wordList)

    // 2. 相同的单词进行分组
    val groupMap: Map[String, List[String]] = wordList.groupBy(word => word)
    println(groupMap)

    // 3. 对分组之后的list取长度，得到每个单词的个数
    val countMap: Map[String, Int] = groupMap.map(kv => (kv._1, kv._2.length))

    // 4. 将map转换为list，并排序取前3
    val sortList: List[(String, Int)] = countMap.toList
      .sortWith( _._2 > _._2 )
      .take(3)

    println(sortList)
}