水善利万物而不争,处众人之所恶,故几于道💦
目录
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
要求集合外部元素类型和集合内部元素类型一致,foldLeft
和foldRight
可以不一致,这两个集合合并的话,明显类型不一致,因为方法调用的时候把其中一个map集合整体作为参数传了进去,这个参数类型是map,而方法调用者是一个map集合,内部元素的类型是一个元组,这一个元组,一个map类型明显不一致,所以不能用fold,那就用foldLeft得了,简单。文章来源:https://www.toymoban.com/news/detail-582634.html
最后合并的思路是什么? 把其中一个map集合作为参数传递进去,然后再迭代另一个集合的时候取到key和value判断,如果这个key在集合中存在,那么更新它的value,如果这个key在集合中不存在,将这个key和value加入到这个集合中。文章来源地址https://www.toymoban.com/news/detail-582634.html
到了这里,关于Scala集合常用函数 - 高级计算函数的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!