Scala面试题及详细答案100道（11-20）-- 函数式编程基础

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux… 。

一、本文面试题目录

11. 什么是高阶函数？举例说明Scala中的高阶函数应用。

高阶函数是指能够接收其他函数作为参数，或返回一个函数作为结果的函数。这是函数式编程的核心特性之一，允许将函数作为数据处理的基本单元。

原理：在Scala中，函数是一等公民，可以像其他值（如整数、字符串）一样被传递和操作。高阶函数通过接收或返回函数，实现了代码的抽象和复用。

应用场景：

• 集合操作（如map、filter）
• 回调函数
• 函数工厂（返回特定功能的函数）

示例：

// 1. 接收函数作为参数
def applyFunction(num: Int, f: Int => Int): Int = f(num)

// 使用匿名函数作为参数
val doubled = applyFunction(5, x => x * 2)  // 10
val squared = applyFunction(5, x => x * x)  // 25

// 2. 返回函数的高阶函数（函数工厂）
def createAdder(amount: Int): Int => Int = {
  (x: Int) => x + amount  // 返回一个函数
}

val add5 = createAdder(5)
val add10 = createAdder(10)
println(add5(3))   // 8
println(add10(3))  // 13

// 3. 集合操作中的高阶函数
val numbers = List(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter(n => n % 2 == 0)  // List(2, 4)
val squaredNumbers = numbers.map(n => n * n)      // List(1, 4, 9, 16, 25)

12. 解释匿名函数（Lambda表达式）的语法，如何在Scala中使用？

匿名函数（Lambda表达式）是没有名称的函数，通常用于临时定义简单的函数逻辑，作为参数传递给高阶函数。

Scala中匿名函数的语法：

• 基本形式：(参数列表) => 表达式
• 若只有一个参数，可省略参数列表的括号：参数 => 表达式
• 若参数类型可推断，可省略类型声明
• 若表达式有多行，需用大括号{}包裹

原理：匿名函数在编译时会被转换为函数值（FunctionN特质的实例），可以像其他值一样被传递和赋值。

示例：

// 1. 完整语法：带参数类型的匿名函数
val add: (Int, Int) => Int = (a: Int, b: Int) => a + b

// 2. 省略类型（类型推断）
val multiply = (a: Int, b: Int) => a * b  // 自动推断为(Int, Int) => Int

// 3. 单个参数可省略括号
val square = (x: Int) => x * x  // 等价于 (x: Int) => x * x

// 4. 无参数的匿名函数
val getRandom = () => Math.random()

// 5. 多行表达式的匿名函数
val complexFunction = (x: Int) => {
  val doubled = x * 2
  val incremented = doubled + 1
  incremented
}

// 6. 在高阶函数中使用
val numbers = List(1, 2, 3, 4)
numbers.map(x => x * 2)  // List(2, 4, 6, 8)
numbers.filter(x => x % 2 == 0)  // List(2, 4)

// 7. 使用下划线简化（仅适用于简单场景）
numbers.map(_ * 2)  // 等价于 x => x * 2
numbers.filter(_ % 2 == 0)  // 等价于 x => x % 2 == 0

13. 什么是闭包？Scala中闭包的实现原理是什么？

闭包是指能够捕获并访问其作用域外部变量的函数，即使该变量在其原始作用域之外也能被访问。

原理：当函数引用了外部变量时，Scala编译器会创建一个闭包对象，该对象包含函数本身以及被捕获的变量的引用。这使得函数在离开原始作用域后，仍能访问和修改这些变量。

示例：

// 1. 基本闭包示例
def createCounter(initial: Int): () => Int = {
  var count = initial  // 外部变量
  () => {  // 闭包：捕获并修改count变量
    count += 1
    count
  }
}

val counter1 = createCounter(0)
println(counter1())  // 1
println(counter1())  // 2

val counter2 = createCounter(10)
println(counter2())  // 11
println(counter1())  // 3（counter1和counter2各自拥有独立的count变量）

// 2. 捕获val变量
def greetFormatter(prefix: String): String => String = {
  val suffix = "!"  // 不可变外部变量
  (name: String) => s"$prefix $name$suffix"  // 闭包捕获prefix和suffix
}

val helloGreet = greetFormatter("Hello")
println(helloGreet("Alice"))  // "Hello Alice!"
println(helloGreet("Bob"))    // "Hello Bob!"

闭包的特点：

• 可以捕获可变变量（var）并修改其值
• 可以捕获不可变变量（val）并读取其值
• 每个闭包实例拥有独立的捕获变量副本
• 延长了被捕获变量的生命周期

在Scala中，闭包广泛用于函数式编程，尤其是在集合操作、并发编程等场景中。

14. 简述map、flatMap和filter的区别，举例说明它们的用法。

map、flatMap和filter都是Scala集合中常用的高阶函数，用于数据转换和过滤，但用途不同：

• map：对集合中的每个元素应用一个函数，将每个元素转换为新元素，返回与原集合长度相同的新集合。
• flatMap：对集合中的每个元素应用一个返回集合的函数，然后将所有结果"扁平化"为一个单一集合（相当于先map再flatten）。
• filter：根据 predicate 函数（返回布尔值）筛选元素，保留满足条件的元素，返回可能比原集合短的新集合。

示例：

val numbers = List(1, 2, 3, 4, 5)
val words = List("hello", "world", "scala")

// 1. map：元素转换
val doubled = numbers.map(_ * 2)  // List(2, 4, 6, 8, 10)
val wordLengths = words.map(_.length)  // List(5, 5, 5)
val squared = numbers.map(x => x * x)  // List(1, 4, 9, 16, 25)

// 2. flatMap：转换后扁平化
val numbersMapped = numbers.map(x => List(x, x * 2))  // List(List(1,2), List(2,4), List(3,6), List(4,8), List(5,10))
val numbersFlattened = numbers.flatMap(x => List(x, x * 2))  // List(1,2,2,4,3,6,4,8,5,10)

val chars = words.flatMap(_.toCharArray)  // List('h','e','l','l','o','w','o','r','l','d','s','c','a','l','a')

// 3. filter：元素筛选
val evenNumbers = numbers.filter(_ % 2 == 0)  // List(2, 4)
val longWords = words.filter(_.length > 5)    // List()（所有单词长度都是5）
val oddNumbers = numbers.filter(x => x % 2 != 0)  // List(1, 3, 5)

// 4. 组合使用
val result = numbers
  .filter(_ % 2 == 0)  // 先筛选偶数
  .map(_ * 3)          // 再将每个偶数乘以3
  .flatMap(x => List(x, x + 1))  // 最后转换并扁平化

println(result)  // List(6,7, 12,13)

总结：

• 当需要一对一转换元素时，使用map
• 当需要一对多转换并合并结果时，使用flatMap
• 当需要筛选元素时，使用filter

15. foldLeft、foldRight和reduce有什么区别？使用时需要注意什么？

foldLeft、foldRight和reduce都是用于对集合元素进行聚合操作的函数，但它们在实现和用途上有显著区别：

原理：这三个函数都通过迭代集合元素，将二元操作应用于累积结果和当前元素，但迭代方向和初始值处理不同。

示例：

val numbers = List(1, 2, 3, 4)

// 1. foldLeft：从左到右聚合，语法：foldLeft(初始值)(聚合函数)
val sumLeft = numbers.foldLeft(0)((acc, num) => acc + num)  // 10
// 等价于：(((0 + 1) + 2) + 3) + 4

// 字符串拼接（返回类型与元素类型不同）
val strLeft = numbers.foldLeft("")((acc, num) => acc + num)  // "1234"

// 2. foldRight：从右到左聚合，语法：foldRight(初始值)(聚合函数)
val sumRight = numbers.foldRight(0)((num, acc) => num + acc)  // 10
// 等价于：1 + (2 + (3 + (4 + 0)))

// 列表构建（展示foldRight的特殊用途）
val reversed = numbers.foldRight(List.empty[Int])((num, acc) => num :: acc)  // List(1,2,3,4)

// 3. reduce：无初始值，使用第一个元素作为初始值
val sumReduce = numbers.reduce((acc, num) => acc + num)  // 10
// 等价于：(((1 + 2) + 3) + 4)

// 求最大值
val maxNum = numbers.reduce((acc, num) => if (num > acc) num else acc)  // 4

// 注意：reduce在空集合上会抛出异常
// List.empty[Int].reduce(_ + _)  // 抛出UnsupportedOperationException

使用注意事项：

• reduce不能用于空集合，而foldLeft/foldRight可以通过初始值安全处理空集合
• foldRight对于某些集合（如List）可能效率较低，因为需要遍历到末尾
• 对于大型集合，foldLeft通常是更高效的选择
• 当需要聚合结果与元素类型不同时，必须使用foldLeft/foldRight

16. 什么是偏函数（Partial Function）？如何定义和使用偏函数？

偏函数（Partial Function）是只对部分输入值有定义的函数，对于未定义的输入值会抛出MatchError。它是PartialFunction[A, B]特质的实例，表示从类型A到类型B的部分映射。

与普通函数的区别：

• 普通函数对所有可能的输入值都有定义
• 偏函数只对特定输入值有定义，其他值会导致错误

定义方式：

• 使用case语句的集合定义偏函数
• 实现isDefinedAt（检查输入是否在定义范围内）和apply（函数逻辑）方法

示例：

// 1. 使用case语句定义偏函数（最常用方式）
val evenNumberHandler: PartialFunction[Int, String] = {
  case x if x % 2 == 0 => s"$x is even"
}

// 2. 检查偏函数是否对输入有定义
println(evenNumberHandler.isDefinedAt(2))  // true
println(evenNumberHandler.isDefinedAt(3))  // false

// 3. 应用偏函数（只对定义的输入有效）
println(evenNumberHandler(2))  // "2 is even"
// evenNumberHandler(3)  // 抛出MatchError

// 4. 组合偏函数（orElse）
val oddNumberHandler: PartialFunction[Int, String] = {
  case x if x % 2 != 0 => s"$x is odd"
}

val numberHandler = evenNumberHandler orElse oddNumberHandler
println(numberHandler(2))  // "2 is even"
println(numberHandler(3))  // "3 is odd"

// 5. 在集合操作中使用偏函数（collect方法）
val numbers = List(1, 2, 3, 4, "a", 5.5)

// collect结合偏函数：过滤并转换元素
val integers = numbers.collect {
  case x: Int => x * 2
}
println(integers)  // List(2, 4, 6, 8)

// 6. 手动实现PartialFunction特质
val positiveHandler = new PartialFunction[Int, String] {
  override def isDefinedAt(x: Int): Boolean = x > 0
  override def apply(x: Int): String = s"$x is positive"
}

println(positiveHandler(5))  // "5 is positive"

应用场景：

• 处理异构集合（如包含多种类型的List[Any]）
• 实现模式匹配的逻辑分离
• 定义只处理特定情况的回调函数

17. 解释Scala中的柯里化（Currying），其作用是什么？

柯里化（Currying）是将接收多个参数的函数转换为一系列接收单个参数的函数的过程。例如，将(a: A, b: B) => C转换为a: A => (b: B => C)。

原理：柯里化利用了Scala中函数可以返回其他函数的特性，将多参数函数分解为嵌套的单参数函数链。

作用：

• 支持部分应用（Partial Application），可以固定部分参数，动态生成新函数
• 提高代码的模块化和复用性
• 使函数更易于组合
• 便于类型推断和隐式参数的使用

示例：

// 1. 普通多参数函数
def add(a: Int, b: Int): Int = a + b

// 2. 柯里化函数（显式定义）
def addCurried(a: Int)(b: Int): Int = a + b

// 调用柯里化函数
println(addCurried(2)(3))  // 5

// 3. 使用curried方法转换普通函数
val addFunc = (a: Int, b: Int) => a + b
val addFuncCurried = addFunc.curried  // Int => Int => Int

// 4. 部分应用（固定第一个参数，生成新函数）
val add5 = addCurried(5)  // Int => Int
println(add5(3))  // 8
println(add5(10)) // 15

// 5. 柯里化在集合操作中的应用
def multiply(a: Int, b: Int): Int = a * b
val numbers = List(1, 2, 3, 4)

// 使用部分应用的柯里化函数
val multiplyBy2 = multiply(2) _  // 下划线表示部分应用
val doubled = numbers.map(multiplyBy2)  // List(2, 4, 6, 8)

// 6. 柯里化与隐式参数（常见用法）
def greet(name: String)(implicit greeting: String): String = 
  s"$greeting, $name!"

implicit val defaultGreeting: String = "Hello"
println(greet("Alice"))  // "Hello, Alice!"（使用隐式参数）
println(greet("Bob")("Hi"))  // "Hi, Bob!"（显式提供第二个参数）

柯里化在Scala中广泛应用，尤其是在需要灵活组合函数或使用隐式参数的场景中。

18. 什么是惰性求值（Lazy Evaluation）？如何在Scala中实现？

惰性求值（Lazy Evaluation）是一种计算策略，它将表达式的求值延迟到第一次需要其结果时进行，而不是在表达式定义时立即求值。

与急切求值（Eager Evaluation）的区别：

• 急切求值：表达式在定义时立即计算（Scala默认策略）
• 惰性求值：表达式在首次使用时才计算，且只计算一次

在Scala中实现惰性求值的方式：

• 使用lazy关键字修饰val变量
• 使用Stream（已被LazyList替代）等惰性集合

原理：Scala编译器会为惰性值创建一个临时变量和标志位，第一次访问时计算值并存储，后续访问直接返回缓存值。

示例：

// 1. 基本惰性值示例
def expensiveCalculation(): Int = {
  println("Performing expensive calculation...")
  42  // 模拟耗时计算的结果
}

// 急切求值：定义时立即执行
val eagerResult = expensiveCalculation()  // 立即打印并计算

// 惰性求值：首次使用时才执行
lazy val lazyResult = expensiveCalculation()  // 定义时不执行
println("Before accessing lazyResult")
println(lazyResult)  // 首次使用，执行计算并打印
println(lazyResult)  // 再次使用，直接返回缓存值（不执行计算）

// 2. 惰性值在条件语句中的应用
val condition = false

// 即使条件为false，eagerValue也会被计算
val eagerValue = if (condition) expensiveCalculation() else 0

// 条件为false时，lazyValue不会被计算（避免不必要的开销）
lazy val lazyValue = expensiveCalculation()
val result = if (condition) lazyValue else 0

// 3. 惰性集合（LazyList）
val lazyList = LazyList.from(1).map(n => {
  println(s"Processing $n")
  n * 2
})

println("LazyList defined")
val firstThree = lazyList.take(3).toList  // 只计算前3个元素
// 输出：
// Processing 1
// Processing 2
// Processing 3

应用场景：

• 优化性能，避免不必要的计算
• 处理无限序列（如LazyList.from(1)生成无限整数序列）
• 解决循环依赖问题
• 延迟加载资源（如文件、网络连接）

注意：过度使用惰性求值可能导致代码难以理解和调试，应谨慎使用。

19. 函数式编程中的“不可变性”指什么？Scala如何支持不可变性？

函数式编程中的“不可变性”（Immutability）指一旦创建的值或对象就不能被修改，任何修改操作都会产生一个新的对象，而不是改变原有对象。

不可变性的优势：

• 线程安全：无需担心多线程环境下的数据竞争
• 可预测性：对象状态不会意外改变，代码更易于推理
• 可缓存性：不可变对象可以安全地缓存和重用
• 便于调试：状态变化可追踪，减少副作用

Scala对不可变性的支持：

1. 不可变变量：使用val定义不能重新赋值的变量
2. 不可变集合：标准库提供丰富的不可变集合（默认使用），如List、Set、Map等
3. 不可变类：通过只提供val字段创建不可变类
4. 不可变数据结构：支持高效的不可变数据修改（如共享大部分结构的新对象）

示例：

// 1. 不可变变量（val）
val name = "Alice"
// name = "Bob"  // 编译错误：不能重新赋值

// 2. 不可变集合（默认集合都是不可变的）
val numbers = List(1, 2, 3)
val newNumbers = numbers :+ 4  // 创建新列表，原列表不变
println(numbers)  // List(1, 2, 3)（原列表未变）
println(newNumbers)  // List(1, 2, 3, 4)（新列表）

// 3. 不可变类
case class Person(name: String, age: Int)  // 样例类默认是不可变的

val alice = Person("Alice", 30)
// alice.age = 31  // 编译错误：不能修改不可变字段

// 创建修改后的新对象
val olderAlice = alice.copy(age = 31)
println(alice)  // Person(Alice,30)（原对象未变）
println(olderAlice)  // Person(Alice,31)（新对象）

// 4. 不可变集合的高效操作
val map = Map("a" -> 1, "b" -> 2)
val newMap = map + ("c" -> 3)  // 创建新Map，共享原有键值对

注意：Scala并非强制不可变性，而是提供了不可变和可变两种选择（通过scala.collection.immutable和scala.collection.mutable包）。函数式编程风格推荐优先使用不可变数据结构。

20. 如何将一个普通函数转换为尾递归函数？尾递归的优势是什么？

尾递归是一种特殊的递归形式，其中递归调用是函数执行的最后一个操作，没有后续操作需要依赖递归调用的结果。

将普通递归转换为尾递归的步骤：

1. 识别递归函数中的累加器（需要在递归过程中传递的中间结果）
2. 创建辅助函数，将累加器作为参数
3. 在辅助函数中，将递归调用作为最后一个操作，并更新累加器
4. 主函数调用辅助函数，初始化累加器

尾递归的优势：

• 避免栈溢出：尾递归可以被编译器优化为循环，不会增加调用栈深度
• 提高性能：消除了普通递归中的栈帧创建和销毁开销
• 处理大数据：可以安全地处理非常深的递归层次（如大型集合遍历）

示例：

import scala.annotation.tailrec  // 用于验证尾递归

// 1. 普通递归（计算阶乘）- 可能导致栈溢出
def factorial(n: Int): Int = {
  if (n <= 1) 1
  else n * factorial(n - 1)  // 递归调用后还有乘法操作
}

// 2. 转换为尾递归
def factorialTailRec(n: Int): Int = {
  // 辅助函数：包含累加器acc
  @tailrec  // 编译时检查是否为尾递归，不是则报错
  def loop(current: Int, acc: Int): Int = {
    if (current <= 1) acc
    else loop(current - 1, current * acc)  // 递归调用是最后一个操作
  }
  
  loop(n, 1)  // 初始化累加器为1
}

// 3. 普通递归（计算斐波那契数列）
def fibonacci(n: Int): Int = {
  if (n <= 1) n
  else fibonacci(n - 1) + fibonacci(n - 2)  // 两次递归调用，且有加法操作
}

// 4. 转换为尾递归
def fibonacciTailRec(n: Int): Int = {
  @tailrec
  def loop(i: Int, a: Int, b: Int): Int = {
    if (i == n) a
    else loop(i + 1, b, a + b)  // 尾递归调用
  }
  
  loop(0, 0, 1)
}

// 测试
println(factorialTailRec(5))  // 120
println(fibonacciTailRec(10))  // 55

注意：

• 使用@tailrec注解可以让编译器检查函数是否真的是尾递归，避免错误
• 并非所有递归都能转换为尾递归（如树的后序遍历）
• 尾递归优化只在Scala编译器中生效，解释器环境可能不优化

二、100道Scala面试题目录列表