高阶函数 - 技术栈

1. 数组过滤：筛选符合条件的元素（filter）

filter 是数组最常用的筛选工具，它接收一个返回布尔值的函数，保留函数返回 true 的元素，最终返回新数组。

筛选数组中的偶数
筛选分数中大于 80 分的成绩

scala 复制代码

object base51 {
  def main(args: Array[String]): Unit = {
    // 把数值为偶数的留下来
    val arr1 = Array(1,2,3,4,5)
 //   val arr2 = arr1.filter( x=> {
 //     // println(x)
 //    x%2 == 0
 //  })
    val arr2 = arr1.filter(x => x%2==0)
    arr2.foreach(println)

    var score = Array(90,98,60,49,100)
    //把小于80分的值去掉，只保留大于80分的分数
    var score1 = score.filter(x =>  x>80).foreach(println)

 }
}

2. 数组聚合：元素累加（reduce 与 sum）

当需要对数组元素进行 "合并" 计算（如求和、求积）时，reduce 是核心工具，它通过迭代两两元素计算最终结果；而 sum 是求和的简化 API，本质是 reduce 的封装。

计算数组所有元素的累加和

scala 复制代码

object base52 {
  def main(args: Array[String]): Unit = {
   val arr  = Array(1,2,3,4,5)
    //求数组元素的累加
    val rst = arr.reduce((x, y)=> x + y)
      //val rst = arr.sum

    println(s"rst = ${rst}")
  }
}

3. 聚合方向：从左到右与从右到左（reduceLeft 与 reduceRight）

reduce 本质是 reduceLeft（从左往右迭代），而 reduceRight 会从右往左迭代，二者在非 "交换律" 运算（如减法、除法）中结果完全不同。

对比减法运算中，从左到右与从右到左的聚合结果

scala 复制代码

object base53 {
  //reduce === reduceleft 从左往右
  //           reduceRight 从右往左

  def main(args: Array[String]): Unit = {
   val arr  = Array(1,2,3)
    val rst = arr.reduceLeft( (x, y)=> x - y)

    val rst1 = Array(1,2,3,4).reduceRight( (x, y)=> x - y)

    println(s"rst = ${rst}")
    println(s"rst = ${rst1}")
  }
}

4. 带初始值的聚合：fold

fold 是 reduce 的扩展，它允许传入一个 "初始值"，再基于初始值迭代合并数组元素，适合需要额外基准值的聚合场景（如从 10 开始累加）。

以 10 为初始值，计算数组元素的累加和

scala 复制代码

object base54 {
  //fold:带初值的reduce
  def main(args: Array[String]): Unit = {
   val rst = Array(1,2,3).fold(10)((x,y)=>x+y)
    println(s"rst = ${rst}")
  }
}

5. 默认排序：sorted

sorted 是数组的默认排序工具，无需自定义逻辑，直接按照元素的 "自然顺序" 排序（数值按大小、字符串按字典序）。

对数值数组从小到大排序
对字符串数组按字典序排序

scala 复制代码

object base55 {
  //sorted
  def main(args: Array[String]): Unit = {
 //对数值元素排序：从小到大排序
   var arr =  Array(-1,10,-2,1,2,3).sorted
   arr.foreach(println)

    //对字符元素排序
    var arr2 = Array("zoom", "bus", "apple", "banana", "car").sorted

    arr2.foreach(println)

  }
}

6. 自定义排序：sortWith

当默认排序无法满足需求（如按 "元素到 1 的距离" 排序、按字符串长度排序）时，sortWith 支持通过自定义函数实现排序逻辑。

对数值数组，按 "元素到 1 的距离" 从小到大排序

scala 复制代码

object base56 {
  //sortWith:自定义排序
 //sortWith( (x,y) => 布尔值 ）
 //(1) 如果返回值是true,那么x就在y的前面
 //(1) 如果返回值是false,那么x就在y的后面

  def main(args: Array[String]): Unit = {
    //对数值元素排序：按照离 1 这个点的距离从小到大排序
   var arr =  Array(-1,10,-2,1,2,3).sortWith((x,y) => Math.abs(x - 1) < Math.abs(y - 1) )
     arr.foreach(println)

  }
}

总结：数组操作 API 对比与选型

操作类型	核心 API	适用场景	关键特点
筛选	filter	保留符合条件的元素	返回新数组，不修改原数组
聚合	reduce	无初始值的合并计算	从数组第一个元素开始迭代
聚合	fold	有初始值的合并计算	需传入初始值，灵活性更高
排序	sorted	默认自然顺序排序	数值升序、字符串字典序
排序	sortWith	自定义规则排序	支持任意比较逻辑，灵活度最高