Scala 文件 I/O（手把手讲解）

Scala 文件 I/O 入门：从读写文件到流式处理

在现代编程中，文件 I/O 是最基础也最频繁的操作之一。无论是日志记录、配置读取，还是数据处理，我们几乎每天都在与文件打交道。而 Scala 作为一门兼具函数式与面向对象特性的语言，在处理文件 I/O 时，提供了简洁、安全且强大的 API。今天，我们就来深入聊聊 Scala 文件 I/O 的核心用法，帮助初学者快速上手，也让中级开发者能掌握更优雅的实践方式。

为什么选择 Scala 处理文件 I/O？

很多人会问，Java 有 java.io 和 java.nio，Python 也有内置的 open()，为什么还要用 Scala？答案在于 Scala 的语法优势和函数式编程特性。

想象一下，你有一堆文本文件需要读取并过滤出包含“error”的行。在 Java 中，你得写一堆 try-catch、BufferedReader、while 循环……而在 Scala 中，你可以用一行代码完成同样的逻辑。这种简洁性不仅提升效率，还能减少出错概率。

更重要的是，Scala 的 Source 类（来自 scala.io 包）封装了底层复杂性，提供了一种“声明式”的读取方式，就像写 SQL 一样自然。

使用 Source 读取文件：优雅的入门方式

Scala 提供了 scala.io.Source 类，它是读取文件最推荐的方式。它能自动处理资源关闭，避免内存泄漏。

import scala.io.Source

// 读取一个文本文件的全部内容
val fileContent = Source.fromFile("data.txt", "UTF-8")

// 逐行读取内容
val lines = fileContent.getLines().toList

// 关闭资源（Source 会自动处理，但显式关闭更安全）
fileContent.close()

// 打印前 5 行
lines.take(5).foreach(println)

注释说明：

• Source.fromFile("data.txt", "UTF-8")：打开名为 data.txt 的文件，指定编码为 UTF-8，避免中文乱码。
• .getLines()：返回一个迭代器，逐行读取文件内容，不会一次性加载全部数据到内存。
• .toList：将迭代器转为列表，方便后续操作。
• fileContent.close()：虽然 Source 通常自动关闭，但显式关闭是一种良好习惯。

小贴士：如果文件不存在，这段代码会抛出 FileNotFoundException。生产环境建议用 try-catch 包裹，或使用 Try 类型处理异常。

写入文件：从简单文本到追加模式

写入文件同样简单。Scala 提供了 scala.io.BufferedWriter 的封装，你可以直接使用 Source 的反向操作。

import scala.io.Source
import java.io.{FileWriter, BufferedWriter}

// 写入新文件（覆盖模式）
val writer = new BufferedWriter(new FileWriter("output.txt"))

// 写入多行
writer.write("这是第一行\n")
writer.write("这是第二行\n")
writer.write("这是第三行")

// 关闭写入流
writer.close()

println("文件已成功写入")

注释说明：

• new FileWriter("output.txt")：创建一个文件写入器，若文件不存在则自动创建。
• write() 方法写入字符串，注意手动添加换行符 \n。
• close() 必须调用，否则数据可能未真正写入磁盘。

使用 try-with-resources 更安全（推荐）

为了避免忘记关闭资源，Scala 推荐使用 using 语法（在 Scala 3 中原生支持）或手动封装。

import scala.io.Source

// 推荐方式：使用 try-with-resources 模式
val result = try {
  val source = Source.fromFile("input.txt", "UTF-8")
  val lines = source.getLines().toList
  source.close()
  lines
} catch {
  case e: Exception => println(s"读取文件失败: ${e.getMessage}"); Nil
}

// 输出结果
result.foreach(println)

注释说明：

• try { ... } catch { ... } 是 Scala 中处理异常的标准方式。
• Nil 表示空列表，作为异常时的默认返回值。
• 这种写法比直接调用 getLines() 更安全，尤其适合处理用户输入或外部文件。

处理大文件：流式读取与内存优化

当你面对的是一个 1GB 的日志文件时，一次性加载到内存显然不现实。Scala 的 getLines() 返回的是一个惰性迭代器（lazy iterator），这正是解决大文件问题的关键。

import scala.io.Source

// 流式读取大文件，逐行处理，不占用过多内存
val bigFile = Source.fromFile("large_log.txt", "UTF-8")

// 只处理包含 "ERROR" 的行
val errorLines = bigFile.getLines()
  .filter(_.contains("ERROR"))
  .toList

bigFile.close()

// 输出结果
errorLines.foreach(println)

注释说明：

• filter(_.contains("ERROR"))：使用函数式编程的 filter 方法，只保留包含 “ERROR” 的行。
• toList 会触发实际遍历，但只在需要时才加载数据。
• 由于是惰性求值，即使文件有 100 万行，也只在处理时加载当前行。

形象比喻：想象你有一条无限长的传送带，上面全是日志数据。getLines() 就像一个“只看当前物品”的扫描仪，不会一次性搬运所有货物，而是按需处理。

文件路径与跨平台兼容性

在不同操作系统中，文件路径分隔符不同：Windows 用 \，Linux/macOS 用 /。Scala 提供了 java.nio.file.Paths 来统一处理路径问题。

import java.nio.file.Paths

// 使用 Paths 构建跨平台路径
val path = Paths.get("data", "input.txt")

// 检查文件是否存在
if (java.nio.file.Files.exists(path)) {
  val source = Source.fromFile(path.toString, "UTF-8")
  val content = source.getLines().toList
  source.close()
  content.foreach(println)
} else {
  println("文件不存在")
}

注释说明：

• Paths.get("data", "input.txt")：自动拼接路径，适配不同系统。
• Files.exists(path)：检查文件是否存在，避免异常。
• path.toString：转换为字符串，供 Source.fromFile 使用。

实际案例：统计日志文件中的错误频率

我们来做一个实战项目：统计一个日志文件中各类错误出现的次数。

import scala.io.Source
import scala.collection.mutable.Map

// 读取日志文件，统计错误类型
def countErrorTypes(filename: String): Map[String, Int] = {
  val errorMap = Map.empty[String, Int] // 存储错误类型与计数

  try {
    val source = Source.fromFile(filename, "UTF-8")
    val lines = source.getLines()

    // 遍历每一行，提取错误类型
    for (line <- lines) {
      if (line.contains("ERROR")) {
        // 假设错误类型在括号内，如 ERROR: AuthFailed
        val errorType = line.split("ERROR: ")(1).split("\\s")(0)
        errorMap(errorType) = errorMap.getOrElse(errorType, 0) + 1
      }
    }

    source.close()
  } catch {
    case e: Exception => println(s"处理文件失败: ${e.getMessage}")
  }

  errorMap
}

// 调用函数并输出结果
val results = countErrorTypes("app.log")

if (results.nonEmpty) {
  println("错误类型统计：")
  results.foreach { case (error, count) =>
    println(s"${error}: ${count} 次")
  }
} else {
  println("未发现错误日志")
}

注释说明：

• Map.empty[String, Int]：创建一个空的可变映射，用于计数。
• split("ERROR: ")(1)：将字符串按 "ERROR: " 分割，取第二部分。
• split("\\s")(0)：再按空格分割，取第一个单词作为错误类型。
• getOrElse(key, 0)：若键不存在，返回默认值 0，避免 NoSuchElementException。

总结：Scala 文件 I/O 的核心优势

通过以上内容，我们看到 Scala 文件 I/O 并不复杂，反而因为其函数式风格和安全机制，让文件操作变得更简洁、更可靠。

• 使用 Source.fromFile 简化读取流程；
• 利用惰性求值处理大文件；
• 通过 try-catch 和 close() 保证资源安全；
• 结合 Paths 实现跨平台兼容；
• 用函数式方法（如 filter, map, fold）实现复杂逻辑。

无论你是初学者还是中级开发者，只要掌握了这些核心技巧，就能在实际项目中高效处理文件 I/O 操作。

记住：好的代码，不是写得越多越好，而是越简洁、越安全越好。Scala 文件 I/O 正是这一理念的完美体现。