Scala for Backend Engineering & Functional Programming · 课时

折叠与归约

foldLeft 与 reduce

折叠与归约 是 CoddyKit 上的免费 Scala for Backend Engineering & Functional Programming 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Scala for Backend Engineering & Functional Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。

将多个元素合并为一个

有时您需要将集合中的所有元素合并为一个单一值，例如总和或拼接结果。Scala 提供了 fold、foldLeft、foldRight 和 reduce 来完成此操作。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    println(nums.sum)
    println(nums.product)
  }
}

reduce：不使用初始值进行合并

reduce 使用二元函数逐对合并元素。它至少需要一个元素，否则会抛出异常。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val total = nums.reduce((a, b) => a + b)
    println(total)
    val max = nums.reduce((a, b) => if (a > b) a else b)
    println(max)
  }
}

foldLeft：使用初始值进行合并

foldLeft 接收一个初始种子值和一个函数。对于空集合，它也是安全的（返回种子值），并且允许结果类型与元素类型不同。

语法：xs.foldLeft(seed)((acc, x) => ...)。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val sum = nums.foldLeft(0)((acc, x) => acc + x)
    println(sum)
    val empty = List.empty[Int].foldLeft(0)(_ + _)
    println(empty)
  }
}

累加器模式

在折叠操作中，第一个参数是保存当前累计结果的累加器，第二个参数是当前元素。每一步都会更新累加器。

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("Scala", "is", "great")
    val sentence = words.foldLeft("")((acc, w) => acc + w + " ")
    println(sentence.trim)
  }
}

结果类型可以不同

foldLeft 的一个强大特性是：累加器类型可以与元素类型不同。这里我们将一个数字 List 折叠为 String。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3)
    val joined = nums.foldLeft("nums:")((acc, n) => acc + " " + n)
    println(joined)
  }
}

foldRight：从右侧开始

foldRight 从右到左处理元素。累加器是第二个参数：(x, acc) => ...。对于不可交换的操作，处理方向很重要。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val left = nums.foldLeft("")((acc, x) => acc + x)
    val right = nums.foldRight("")((x, acc) => acc + x)
    println("foldLeft:  " + left)
    println("foldRight: " + right)
  }
}

从左到右还是从右到左，以及性能

foldLeft 使用尾递归，在处理大型列表时不会导致栈溢出。对 List 使用 foldRight 处理非常大的输入时，可能会导致栈溢出。除非顺序要求必须如此，否则请优先使用 foldLeft。

object Main {
  def main(args: Array[String]): Unit = {
    val big = (1 to 100000).toList
    val total = big.foldLeft(0L)((acc, x) => acc + x)
    println(total)
  }
}

使用 fold 构建集合

折叠操作足够通用，甚至可以用来构建集合。这里我们通过将每个元素添加到累加器列表的开头来反转列表。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val reversed = nums.foldLeft(List.empty[Int])((acc, x) => x :: acc)
    println(reversed)
  }
}

使用 reduceOption 提高安全性

由于 reduce 在空集合上会失败，reduceOption 会返回一个 Option：集合非空时返回 Some(result)，为空时返回 None。

object Main {
  def main(args: Array[String]): Unit = {
    println(List(3, 1, 4).reduceOption(_ + _))
    println(List.empty[Int].reduceOption(_ + _))
  }
}

fold：对称变体

fold 类似于 foldLeft，但累加器必须与元素类型相同。它通常用于并行集合。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val total = nums.fold(0)(_ + _)
    println(total)
  }
}

使用 foldLeft 计数

折叠操作可以计算更复杂的结果，例如在一次遍历中统计满足条件的元素数量。

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(4, 7, 2, 9, 6, 1)
    val evenCount = nums.foldLeft(0)((acc, x) => if (x % 2 == 0) acc + 1 else acc)
    println(s"even numbers: $evenCount")
  }
}

快速检查

reduce 和 foldLeft 的关键区别是什么？

回顾

您学习了折叠和归约：

reduce — 逐对合并，不使用种子值，集合为空时失败
reduceOption — 返回 Option 的安全变体
foldLeft — 种子值加累加器，不会栈溢出，结果类型灵活
foldRight — 从右到左处理，在大型列表上需注意栈空间
折叠操作甚至可以构建新的集合

常见问题解答

「折叠与归约」课时是免费的吗？

是的 — 「折叠与归约」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Scala for Backend Engineering & Functional Programming 课程的其余内容，请升级到 CoddyKit PRO。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。

「折叠与归约」这节课中我会学到什么？

foldLeft 与 reduce 你通过在浏览器中直接运行的动手代码来练习 Scala for Backend Engineering & Functional Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Scala for Backend Engineering & Functional Programming 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Scala for Backend Engineering & Functional Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「折叠与归约」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Scala for Backend Engineering & Functional Programming 课中编写并运行代码吗？

能。每节 Scala for Backend Engineering & Functional Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Scala for Backend Engineering & Functional Programming