说明

1. 过滤 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
2. 转化/映射（map）将集合中的每一个元素映射到某一个函数
3. 扁平化 扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten 操作集合中的每个元素的子元素映射到某个函数并返回新集合
4. 分组(group) 按照指定的规则对集合的元素进行分组
5. 简化（归约）
6. 折叠

   object CollectionAdvancedFunctions {
     def main(args: Array[String]): Unit = {
       val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
       val nestedList = List(List(1, 2), List(3, 4), List(5, 6))
   
       // 1. 过滤(filter): 筛选偶数
       val evenNumbers = numbers.filter(_ % 2 == 0)
       println(s"Filtered even numbers: $evenNumbers")  // List(2, 4, 6, 8, 10)
   
       // 2. 映射(map): 平方每个元素
       val squaredNumbers = numbers.map(x => x * x)
       println(s"Squared numbers: $squaredNumbers")     // List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
   
       // 3. 扁平化(flatten): 展开嵌套集合
       val flattenedList = nestedList.flatten
       println(s"Flattened list: $flattenedList")       // List(1, 2, 3, 4, 5, 6)
   
       // 4. flatMap: 组合map和flatten
       val flatMapped = numbers.flatMap(n => List(n, n*10))
       println(s"FlatMapped list: $flatMapped")        // List(1,10, 2,20,...,10,100)
   
       // 5. 分组(groupBy): 按奇偶分组
       val groupedNumbers = numbers.groupBy(n => if (n % 2 == 0) "even" else "odd")
       println(s"Grouped numbers: $groupedNumbers")    
       // Map(odd -> List(1,3,5,7,9), even -> List(2,4,6,8,10))
   
       // 6. 归约(reduce): 计算乘积
       val product = numbers.reduce((a, b) => a * b)
       println(s"Product via reduce: $product")         // 3628800
   
       // 7. fold: 带初始值的归约
       val sumWithFold = numbers.fold(100)(_ + _)       // 初始值100 + 1+2+...+10
       println(s"Sum with fold: $sumWithFold")          // 155
   
       // 8. 组合操作: 过滤奇数 -> 平方 -> 求和
       val combined = numbers
         .filter(_ % 2 != 0)  // 过滤奇数 List(1,3,5,7,9)
         .map(x => x * x)      // 平方 List(1,9,25,49,81)
         .sum                  // 求和 1+9+25+49+81 = 165
       println(s"Combined operations result: $combined") // 165
     }
   }

   Reduce 方法

   object TestReduce {
   
      def main(args: Array[String]): Unit = 
          { val list = List(1,2,3,4)
          // 将数据两两结合，实现运算规则
   
          val i: Int = list.reduce( (x,y) => x-y ) 
          println("i = " + i)
   
          // 从源码的角度，reduce 底层调用的其实就是 reduceLeft
          //val i1 = list.reduceLeft((x,y) => x-y)
   
          // ((4-3)-2-1) = -2
          val i2 = list.reduceRight((x,y) => x-y)
          println(i2)
       }
   }
   

   Fold 方法

   Fold 折叠：化简的一种特殊情况。

   object TestFold {
   
      def main(args: Array[String]): Unit = 
          { val list = List(1,2,3,4)
   
          // fold 方法使用了函数柯里化，存在两个参数列表
          // 第一个参数列表为 ： 零值（初始值）
          // 第二个参数列表为： 简化规则
   
          // fold 底层其实为 foldLeft
          val i = list.foldLeft(1)((x,y)=>x-y)
          val i1 = list.foldRight(10)((x,y)=>x-y)
          println(i)
          println(i1)
      }
   }
   

复杂wordcount实验案例

object WordCount {
  def main(args: Array[String]): Unit = {
    // 示例输入文本
    val text = 
      """Hello Scala world
        |Hello Spark world
        |Scala is awesome
        |Spark is powerful
      """.stripMargin

    // 多步骤处理流程
    val wordCounts = text
      .split("\n")                // 按行切割
      .flatMap(line => 
        line.trim
          .replaceAll("[^a-zA-Z ]", "")  // 去除非字母字符
          .toLowerCase()                 // 统一小写
          .split("\\s+")                 // 按任意空格分割
      )
      .filter(_.nonEmpty)          // 过滤空字符串
      .groupMapReduce(identity)(_ => 1)(_ + _)  // 分组统计
      .toList
      .sortBy(-_._2)              // 按词频降序排序

    // 打印结果
    println("Word Count Results:")
    wordCounts.foreach { case (word, count) => 
      println(f"$word%-10s $count%3d")
    }
  }
}