【Scala】集合高级计算

集合高级计算

（ 1 ）过滤
遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
（ 2 ） 转化 / 映射（ map ）
将集合中的每一个元素映射到某一个函数
（ 3 ）扁平化
（ 4 ）扁平化 + 映射 注： flatMap 相当于先进行 map 操作，在进行 flatten 操作集合中的每个元素的子元素映射到某个函数并返回新集合
（ 5 ） 分组 (group)
按照指定的规则对集合的元素进行分组
（ 6 ）简化（归约）
（ 7 ）折叠
————————————————
版权声明：本文为CSDN博主「不断学习的克里斯」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_65025800/article/details/122587650

实例

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)
}

标签：map,String,val,Scala,List,高级,println,集合,hello
来源： https://www.cnblogs.com/LittleOctopus/p/16627809.html