集合计算高级函数

说明

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

折叠

Scala 复制代码

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 方法

Scala 复制代码

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 折叠：化简的一种特殊情况。

Scala 复制代码

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实验案例

Scala 复制代码

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")
    }
  }
}