Scala集合常用函数 - 高级计算函数

这篇具有很好参考价值的文章主要介绍了Scala集合常用函数 - 高级计算函数。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

水善利万物而不争,处众人之所恶,故几于道💦

目录

  1. 过滤 - filter
  2. 转换/映射 - map
  3. 扁平化 - flatten
  4. 扁平化+映射 - flatMap
  5. 分组 - groupBy
  6. 简化(规约) - reduce
  7. 折叠 - fold
  8. 函数小练习

1. 过滤 - filter

 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
//对List集合进行遍历,将偶数取出,放到新的集合中去

val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

println(list.filter((a: Int) => {a % 2 == 0}))

println(list.filter(_ % 2 == 0))

  filter()方法的参数是一个函数类型,其返回值为布尔类型,函数体指明过滤的规则。

2. 转换/映射 - map

 将集合中的每一个元素映射到某一个函数
//将集合中的元素进行乘2操作
println(list.map(_ * 2))

3. 扁平化 - flatten

flatten函数用于将嵌套的集合展平为一个单层的集合。它将嵌套的集合中的元素取出来,放入一个新的集合中。

flatten函数只对嵌套的集合有效,如果集合中的元素不是集合类型,则flatten函数不会有任何效果

注意: :::操作符用于连接两个集合,它将两个集合合并成一个新的集合。它接受右侧的集合作为参数,并将其添加到左侧的集合之后。而flatten函数用于将嵌套的集合展平为一个单层的集合。它们的功能和用途是不同的

val list1 = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
val newList1: List[Int] = list1.flatten
println(newList1)

结果:
List(1, 2, 3, 4, 5, 6, 7, 8, 9)

4. 扁平化+映射 - flatMap

flatMap相当于先进行map操作,再进行flatten操作
val strings = List("hello atguigu", "hello jingjing", "qcln jingjing")

//常规实现
val stringses: List[Array[String]] = strings.map(_.split(" "))
println(stringses.flatten)

// 使用flatMap函数实现
val strings2: List[String] = strings.flatMap(_.split(" "))
println(strings2)

5. 分组 - groupBy

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

val nameList = List("jingjing", "banzhang", "banhua", "anqcln", "jinghua")

// 按元素首字母进行分组
val charToStrings: Map[Char, List[String]] = nameList.groupBy(_.charAt(0))
println(charToStrings)

结果:
Map(b -> List(banzhang, banhua), j -> List(jingjing, jinghua), a -> List(anqcln))

进阶:修改分组后key的值
  直接再进行一次map映射

// 将分组后key的值改为大写
val keyStyle1: immutable.Iterable[String] = charToStrings.map(MapKv => {
      val upperKey: Char = MapKv._1.toUpper
      upperKey + " -- " + MapKv._2
    })
println(keyStyle1)

// 将分组后key为b的值改为X
val keyStyle2: immutable.Iterable[String] = charToStrings.map(MapKV => {
  val newKey = if (MapKV._1.equals('b')) 'X' else MapKV._1
  newKey + " -- " + MapKV._2
})
println(keyStyle2)

  说明:Scala中if条件判断其实是有返回值的,返回值取决于满足条件的代码体的最后一行内容。

6. 简化(规约) - reduce

 通过指定的逻辑将集合中的数据进行聚合,从而减少数据,最终获取结果

reduce:底层调用的是reduceLeft。他要求传入的两个参数的类型必须一致,返回值也是该类型。

reduceLeft:传入的两个参数的参数类型可以不一致。它从集合左边开始做聚合,返回值类型是左边的类型。

reduceRight:传入的两个参数的参数类型可以不一致。它从集合右边开始做聚合,返回值类型是右边的类型。

val list = List(1, 2, 3, 4)

val res: Int = list.reduce(_ + _)
val res: Int = list.reduceLeft(_ + _)
val res: Int = list.reduceRight(_ + _)
println(res)

println(list.reduceLeft(_ - _))  // -8
println(list.reduceRight(_ - _))  // -2

val list2: List[Int] = List(3, 4, 5, 8, 10)
println(list2.reduceRight(_ - _))   // 6

reduceLeft:从左边开始简化,用第一个元素减去第二个元素,然后再用结果减去第三个元素

reduceRight:从右边开始简化,用倒数第二个元素减去倒数第一个元素,再用倒数第三个元素减去上一个结果

从源码角度理解reduceRight的计算方法

7. 折叠 - fold

 简化的一种特殊情况,它是集合外元素和集合内部元素进行聚合。计算方式和简化相似。

val list2: List[Int] = List(3, 4, 5, 8, 10)  

println(list2.fold(10)(_+_))  // 40

println(list2.foldLeft(11)(_ - _))  // -19

println(list2.foldRight(12)(_ - _))   // -6

foldLeft:从左边开始折叠,用集合外的元素减去集合左边第一个元素,再用结果减去第二个元素,以此类推

foldRight:从右边开始折叠,用集合最后一个元素减去集合外的元素,再用集合倒数第二个元素减去结果,以此类推


8. 函数小练习

将两个map集合中的数据合并(key相同的话,value相加)

val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
val map2 = mutable.Map("a"->4, "b"->5, "d"->6)


//方法一   
// map1("e") = 9 这样也能添加元素....
val res: mutable.Map[String, Int] = map1.foldLeft(map2)(
  // m2Jh表示map2,m1表示map1中的每一个元素
  (m2Jh, m1) => {
    // 指定合并的规则
    val m1Key: String = m1._1
    val m1Value: Int = m1._2
    // 根据map1中元素的key更新map2中的value,或者直接添加
    m2Jh(m1Key) = m2Jh.getOrElse(m1Key, 0) + m1Value 
    m2Jh
  })

//  ================================== 方法二 ================================= 
// 我写的,通俗易懂
val res: mutable.Map[String, Int] = map1.foldLeft(map2)((m2Jh, m1) => {
  val m1Key: String = m1._1
  val m1Value: Int = m1._2

  // 在map2中获取value,如果获取到,执行update更新value,如果获取不到执行put添加
  val flag: Int = m2Jh.getOrElse(m1Key, 0)  
  if(flag==0){
    m2Jh.put(m1Key,m1Value)
  }else{
    m2Jh.update(m1Key,m1Value+flag)
  }
  m2Jh  // 将map2集合返回,因为foldLeft()()的参数类型就要求的
})

println(res)

分析:

  两个集合合并,涉及到两个集合,用折叠fold

  折叠有三个,具体选哪个,fold要求集合外部元素类型和集合内部元素类型一致,foldLeftfoldRight可以不一致,这两个集合合并的话,明显类型不一致,因为方法调用的时候把其中一个map集合整体作为参数传了进去,这个参数类型是map,而方法调用者是一个map集合,内部元素的类型是一个元组,这一个元组,一个map类型明显不一致,所以不能用fold,那就用foldLeft得了,简单。

  最后合并的思路是什么? 把其中一个map集合作为参数传递进去,然后再迭代另一个集合的时候取到key和value判断,如果这个key在集合中存在,那么更新它的value,如果这个key在集合中不存在,将这个key和value加入到这个集合中。文章来源地址https://www.toymoban.com/news/detail-582634.html

到了这里,关于Scala集合常用函数 - 高级计算函数的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Scala集合 - Set

    水善利万物而不争,处众人之所恶,故几于道💦 一、不可变Set集合   1. 创建集合   2. 添加元素   3. 删除元素   4. 遍历集合 二、可变Set集合   1. 创建可变集合   2. 添加元素   3. 删除元素   4. 遍历集合 1. 创建集合   Set点进去是个特质,没法new,直接用伴生对象的

    2024年02月16日
    浏览(67)
  • 【Scala】集合

    目录 类型 不可变集合 可变集合 数组 不可变 可变数组 不可变数组与可变数组的转换 多维数组 List list运算符 可变 ListBuffer Set 集合 不可变 Set 可变 mutable.Set Map 集合 可变 Map 元组 操作 通用操作 衍生集合操作 计算函数 排序 sorted sortBy sortWith 计算高级函数 实例 WordCount 案例

    2023年04月09日
    浏览(36)
  • Scala集合

    scala中的集合分为两种 ,可变集合和不可变集合, 不可变集合可以安全的并发的访问! 集合的类主要在一下两个包中 可变集合包 scala.collection.mutable 不可变集合包 scala.collection.immutable 默认的 Scala 不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而不会对

    2024年01月20日
    浏览(38)
  • Scala集合 - List

    水善利万物而不争,处众人之所恶,故几于道💦 一、不可变List   1. 创建List   2. 取指定的数据   3. 向List中添加元素   4. 遍历List   5. 集合间合并 - 扁平化处理 二、可变List   1. 创建可变集合对象   2. 添加元素   3. 修改元素   4. 删除元素 1. 创建List   创建一个L

    2024年02月15日
    浏览(43)
  • Scala集合继承体系图

    1) Scala 的集合有三大类:序列 Seq、集Set、映射 Map,所有的集合都扩展自 Iterable特质。 2) 对于几乎所有的集合类,Scala 都同时提供了可变和不可变的版本,分别位于以下两个包 不可变集合:scala.collection.immutable 可变集合: scala.collection.mutable 3) Scala 不可变集合,就是指该

    2024年02月10日
    浏览(61)
  • Scala之集合(2)

      目录 集合基本函数: (1)获取集合长度 (2)获取集合大小 (3)循环遍历 (4)迭代器 (5)生成字符串 (6)是否包含 衍生集合: (1)获取集合的头 (2)获取集合的尾 (3)集合最后一个数据 (4)集合初始数据 (5)反转 (6)取前(后)n 个元素 (7)去掉前(后)

    2024年02月02日
    浏览(37)
  • Scala之集合(3)

      目录   WordCount案例: 需求分析与步骤: 拆分: 聚合: 格式转化: 方法1: 方法2: 排序: 方法1: 方法2: 取top3: 整体化简后的代码: WordCoount案例升级: 给定数据: 方法1: 方法2: 方法3: 并行集合:   聚合过程较为繁琐,分为以下几步: (1)先将切割后的List集合

    2023年04月24日
    浏览(34)
  • 第7章 Scala集合

    ​ ​ scala.collection.immutable ​ scala.collection.mutable ​ ​ 不可变数组 可变数组 多维度数组 不可变列表 可变列表 不可变Set 可变Set ​ 不可变Map 可变Map ​ 通用属性和操作 衍生集合 ​ 简单计算函数 ​ 高级计算函数 ​​ ​ 应用案例-合并Map 队列 ​ 并行集合 ​

    2024年02月10日
    浏览(42)
  • Scala之集合(1)

    目录 ​​​​​​​集合介绍: 不可变集合继承图:​编辑  可变集合继承图 数组: 不可变数组: 样例代码: 遍历集合的方法: 1.for循环 2.迭代器 3.转换成List列表: 4.使用foreach()函数: 可变数组: ArrayBuffer: 二维数组:  List集合: Set 集合: 不可变 Set: 可变Set: Map集合

    2023年04月18日
    浏览(34)
  • Scala的队列与并行集合

    在 Scala 中,队列和并行集合是常用的数据结构和并发编程工具。 Scala 提供了可变和不可变两种队列。可变队列通过 scala.collection.mutable.Queue 类来实现,而不可变队列通过 scala.collection.immutable.Queue 类来实现。 可变队列可以动态添加、移除和检索元素,常用的方法包括 enqueue 和

    2024年02月10日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包