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

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映射

scala 复制代码

// 将分组后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：传入的两个参数的参数类型可以不一致。它从集合右边开始做聚合，返回值类型是右边的类型。

scala 复制代码

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

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

scala 复制代码

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相加)

scala 复制代码

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得了，简单。

最后合并的思路是什么？把其中一个map集合作为参数传递进去，然后再迭代另一个集合的时候取到key和value判断，如果这个key在集合中存在，那么更新它的value，如果这个key在集合中不存在，将这个key和value加入到这个集合中。

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

目录

[ 1. 过滤 - filter](# 1. 过滤 - filter)

[ 2. 转换/映射 - map](# 2. 转换/映射 - map)

[ 3. 扁平化 - flatten](# 3. 扁平化 - flatten)

[ 4. 扁平化+映射 - flatMap](# 4. 扁平化+映射 - flatMap)

[ 5. 分组 - groupBy](# 5. 分组 - groupBy)

[ 6. 简化（规约） - reduce](# 6. 简化（规约） - reduce)

[ 7. 折叠 - fold](# 7. 折叠 - fold)

[ 8. 函数小练习](# 8. 函数小练习)

1. 过滤 - filter

2. 转换/映射 - map

3. 扁平化 - flatten

4. 扁平化+映射 - flatMap

5. 分组 - groupBy

6. 简化（规约） - reduce

7. 折叠 - fold

8. 函数小练习