C/C++教程

【Scala】集合高级计算

本文主要是介绍【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)
}
这篇关于【Scala】集合高级计算的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!