Scala中val与var的使用场景及集合组合实践问询

一、val与var的核心适用场景 #

Scala的核心原则是优先用val，val是不可变变量，绑定后指针无法修改，能避免可变状态带来的潜在bug，契合函数式编程的设计理念。

循环求和的优化写法 #

如果你的原var循环求和写法是这样：

var sum = 0
for (num <- 1 to 10) sum += num

完全可以用纯函数式方式替代，无需使用var：

// 方式1：用foldLeft实现累加
val sum = (1 to 10).foldLeft(0)((acc, num) => acc + num)
// 更简洁的语法糖写法
val sum = (1 to 10).foldLeft(0)(_ + _)

// 方式2：直接调用集合的sum方法（仅适用于数值类型集合）
val sum = (1 to 10).sum

这种写法无可变状态，代码更简洁，也更符合Scala的风格。

二、val/var与可变/不可变集合的四种组合分析 #

先明确两个核心维度：

• 变量可变性（val/var）：val绑定的变量指针不可变，var的指针可重新赋值
• 集合可变性：不可变集合（如scala.collection.immutable.List）内部元素/结构不可修改；可变集合（如scala.collection.mutable.ListBuffer）内部可直接修改

1. val + 不可变集合（最推荐） #

• 合理性：变量指针固定，集合内部完全不可变，无任何可变状态，线程安全，是函数式编程的理想选择
• 最佳实践：绝大多数业务场景优先使用，比如数据处理、函数参数传递、返回值定义等
• 集合变更逻辑：不可变集合的"添加/更新"操作本质是返回全新的集合实例，原集合不会有任何变化。例如List的:+操作：

  val oldList = List(1,2,3)
  val newList = oldList :+ 4  // oldList仍为List(1,2,3)，newList是新的List(1,2,3,4)
  

2. val + 可变集合（谨慎使用） #

• 合理性：变量指针固定，但可修改集合内部的元素或结构，适合需要在同一个集合实例上批量修改的场景（比如动态构建元素较多的集合）
• 最佳实践：仅在需要高效修改集合内部状态时使用，且尽量将集合控制在局部作用域内，不要暴露给外部代码，避免引发状态混乱
• 集合变更逻辑：直接修改集合实例的内部状态，变量始终指向同一个实例。例如ListBuffer的+=操作：

  val buffer = scala.collection.mutable.ListBuffer(1,2,3)
  buffer += 4  // buffer内部变为ListBuffer(1,2,3,4)，指针未变
  

3. var + 不可变集合（偶尔可用） #

• 合理性：变量指针可重新赋值，每次"更新"集合时，变量指向新的不可变集合实例，适合需要逐步构建不可变集合的复杂场景
• 最佳实践：尽量用函数式操作（如foldLeft）替代，只有当函数式写法过于繁琐时才考虑。例如：

  var list = List.empty[Int]
  for (i <- 1 to 3) list = list :+ i
  // 更优的函数式写法
  val list = (1 to 3).foldLeft(List.empty[Int])((acc, i) => acc :+ i)
  

• 集合变更逻辑：修改的是变量的指针，指向新的不可变集合实例，原集合实例保持不变

4. var + 可变集合（不推荐） #

• 合理性：变量指针和集合内部都可变，可变状态最多，线程不安全，极易引发难以排查的bug
• 最佳实践：除非是和Java旧代码交互等特殊场景，否则绝对避免使用

三、不可变集合"更新未生效"问题解析 #

很多人会遇到这种情况：

val list = List(1,2,3)
list :+ 4
println(list)  // 输出还是List(1,2,3)

原因很直白：不可变集合的所有修改操作都不会改变原实例，只会返回新的集合。上述代码中，list :+ 4生成了新集合，但没有将新集合赋值给任何变量，原list依然指向原来的不可变实例。

如果需要保留新集合，要么赋值给新的val：

val newList = list :+ 4

要么（不推荐）用var重新赋值：

var list = List(1,2,3)
list = list :+ 4

内容的提问来源于stack exchange，提问作者ni al