如何在 Scala 中写入文件？

Question

对于阅读来说，有一个有用的抽象Source。如何将行写入文本文件？

Answer 1

这是标准 Scala 中缺少的功能之一，我发现它非常有用，因此我将其添加到我的个人库中。 （您可能也应该有一个个人库。）代码如下所示：

def printToFile(f: java.io.File)(op: java.io.PrintWriter => Unit) {
  val p = new java.io.PrintWriter(f)
  try { op(p) } finally { p.close() }
}

并且使用方式如下：

import java.io._
val data = Array("Five","strings","in","a","file!")
printToFile(new File("example.txt")) { p =>
  data.foreach(p.println)
}

Answer 2

编辑 2019 年（8 年后），Scala-IO 不是很活跃（如果有的话），< a href="https://stackoverflow.com/users/871202/li-haoyi">李浩毅推荐了他自己的库lihaoyi/os-lib，他在下面介绍。

2019 年 6 月，Xavier Guihot 在 使用，一个用于执行自动资源管理的实用程序。

---

编辑（2011 年 9 月）：自从 Eduardo Costa 询问 Scala2.9 以来，自从 Rick-777 评论 scalax.IO 提交历史 自 2009 年中期以来几乎不存在...

Scala-IO 已更改位置：请参阅其 GitHub 存储库，来自 Jesse Eichar （也就这样）：

Scala IO 伞项目由几个针对 IO 不同方面和扩展的子项目组成。
Scala IO 有两个主要组件：

• 核心 - 核心主要处理从任意源和接收器读取和写入数据。基石特征是提供核心 API 的输入、输出 和Seekable。
  其他重要的类是 Resource、ReadChars 和 WriteChars。
• 文件 - 文件是一个文件（称为路径）API，基于 Java 7 NIO 文件系统和 SBT PathFinder API 的组合.
  Path 和 FileSystem 是 Scala IO File API 的主要入口点。

import scalax.io._

val output:Output = Resource.fromFile("someFile")

// Note: each write will open a new connection to file and 
//       each write is executed at the begining of the file,
//       so in this case the last write will be the contents of the file.
// See Seekable for append and patching files
// Also See openOutput for performing several writes with a single connection

output.writeIntsAsBytes(1,2,3)
output.write("hello")(Codec.UTF8)
output.writeStrings(List("hello","world")," ")(Codec.UTF8)

---

原始答案（2011年1月），与scala-io的旧地方：

如果你不想等待Scala2.9，你可以使用 scala-incubator / scala-io 库。
（如“为什么Scala Source不关闭底层InputStream？ ”）

请参阅样品

{ // several examples of writing data
    import scalax.io.{
      FileOps, Path, Codec, OpenOption}
    // the codec must be defined either as a parameter of ops methods or as an implicit
    implicit val codec = scalax.io.Codec.UTF8


    val file: FileOps = Path ("file")

    // write bytes
    // By default the file write will replace
    // an existing file with the new data
    file.write (Array (1,2,3) map ( _.toByte))

    // another option for write is openOptions which allows the caller
    // to specify in detail how the write should take place
    // the openOptions parameter takes a collections of OpenOptions objects
    // which are filesystem specific in general but the standard options
    // are defined in the OpenOption object
    // in addition to the definition common collections are also defined
    // WriteAppend for example is a List(Create, Append, Write)
    file.write (List (1,2,3) map (_.toByte))

    // write a string to the file
    file.write("Hello my dear file")

    // with all options (these are the default options explicitely declared)
    file.write("Hello my dear file")(codec = Codec.UTF8)

    // Convert several strings to the file
    // same options apply as for write
    file.writeStrings( "It costs" :: "one" :: "dollar" :: Nil)

    // Now all options
    file.writeStrings("It costs" :: "one" :: "dollar" :: Nil,
                    separator="||\n||")(codec = Codec.UTF8)
  }

Answer 3

与 Rex Kerr 的答案类似，但更通用。首先我使用辅助函数：

/**
 * Used for reading/writing to database, files, etc.
 * Code From the book "Beginning Scala"
 * http://www.amazon.com/Beginning-Scala-David-Pollak/dp/1430219890
 */
def using[A <: {def close(): Unit}, B](param: A)(f: A => B): B =
try { f(param) } finally { param.close() }

然后我将其用作：

def writeToFile(fileName:String, data:String) = 
  using (new FileWriter(fileName)) {
    fileWriter => fileWriter.write(data)
  }

等等

def appendToFile(fileName:String, textData:String) =
  using (new FileWriter(fileName, true)){ 
    fileWriter => using (new PrintWriter(fileWriter)) {
      printWriter => printWriter.println(textData)
    }
  }

。

Answer 4

一个简单的答案：

import java.io.File
import java.io.PrintWriter

def writeToFile(p: String, s: String): Unit = {
    val pw = new PrintWriter(new File(p))
    try pw.write(s) finally pw.close()
  }

Answer 5

给出另一个答案，因为我对其他答案的编辑被拒绝。

这是最简洁和简单的答案（类似于 Garret Hall 的）

File("filename").writeAll("hello world")

这类似于 Jus12，但没有冗长且正确的 代码风格

def using[A <: {def close(): Unit}, B](resource: A)(f: A => B): B =
  try f(resource) finally resource.close()

def writeToFile(path: String, data: String): Unit = 
  using(new FileWriter(path))(_.write(data))

def appendToFile(path: String, data: String): Unit =
  using(new PrintWriter(new FileWriter(path, true)))(_.println(data))

请注意，try finally 不需要大括号，也不需要 lambda，并注意占位符语法的使用。还要注意更好的命名。

Answer 6

不幸的是，对于最重要的答案，Scala-IO 已经死了。如果您不介意使用第三方依赖项，请考虑使用我的 OS-Lib 库。这使得处理文件、路径和文件系统变得非常容易：

// Make sure working directory exists and is empty
val wd = os.pwd/"out"/"splash"
os.remove.all(wd)
os.makeDir.all(wd)

// Read/write files
os.write(wd/"file.txt", "hello")
os.read(wd/"file.txt") ==> "hello"

// Perform filesystem operations
os.copy(wd/"file.txt", wd/"copied.txt")
os.list(wd) ==> Seq(wd/"copied.txt", wd/"file.txt")

它具有用于写入文件<的单行代码< /a>, 附加到文件, 覆盖文件，以及许多其他有用/常见的操作

Answer 7

下面是使用 Scala 编译器库的简洁单行：

scala.tools.nsc.io.File("filename").writeAll("hello world")

或者，如果您想使用 Java 库，您可以执行以下 hack：

Some(new PrintWriter("filename")).foreach{p => p.write("hello world"); p.close}

Answer 8

一个用于使用 java.nio 保存/读取 String 的衬垫。

import java.nio.file.{Paths, Files, StandardOpenOption}
import java.nio.charset.{StandardCharsets}
import scala.collection.JavaConverters._

def write(filePath:String, contents:String) = {
  Files.write(Paths.get(filePath), contents.getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE)
}

def read(filePath:String):String = {
  Files.readAllLines(Paths.get(filePath), StandardCharsets.UTF_8).asScala.mkString
}

这不适合大文件，但可以完成工作。

一些链接：

java.nio.file.Files.write
java .lang.String.getBytes
scala.collection.JavaConverters
scala.collection.immutable.List.mkString

Answer 9

从 Scala 2.13 开始，标准库提供了专用的资源管理实用程序：使用。

在这种情况下，它可以与诸如 PrintWriter 或 BufferedWriter 扩展 < code>AutoCloseable 以便写入文件，并且无论如何，之后关闭资源：

• 例如，使用 java.io API：

  导入 scala.util.Using, java.io.{PrintWriter, File}
  
  // vallines = List("hello", "world")
  使用(new PrintWriter(new File("file.txt"))) {
    作者=> lines.foreach(writer.println)
  }
  

• 或者使用 java.nio API：

  import scala.util.Using, java.nio.file.{文件, 路径}, java.nio.charset.Charset
  
  // vallines = List("hello", "world")
  使用（Files.newBufferedWriter（Paths.get（“file.txt”），Charset.forName（“UTF-8”）））{
    作者=> lines.foreach(line => writer.write(line + "\n"))
  }
  

Answer 10

我编写的微型库： https://github.com/pathikrit/better-files

file.appendLine("Hello", "World")

或

file << "Hello" << "\n" << "World"

Answer 11

2019 年 9 月 1 日更新：

• 从 Scala 2.13 开始，更喜欢使用 scala.util.Using
• 修复了 finally 会吞下 try 抛出的原始 Exception 如果 finally 抛出的错误code> code throws an Exception

---

在查看了所有关于如何在 Scala 中轻松编写文件的答案（其中一些非常好）之后，我遇到了三个问题

1. ： ://stackoverflow.com/a/5218279/501113">Jus12的答案，对于Scala/FP初学者来说，使用辅助方法进行柯里化并不明显
2. 需要用scala封装较低级别的错误.util.Try
3. 需要向刚接触 Scala/FP 的 Java 开发人员展示如何正确嵌套依赖资源，以便对每个依赖资源反向执行 close 方法顺序 - 注意：以相反顺序关闭依赖资源特别是在发生故障的情况下是 java.lang.AutoCloseable 规范倾向于导致非常有害且难以发现的错误和运行时故障

在开始之前，我的目标不是简洁。它是为了让 Scala/FP 初学者（通常是来自 Java 的初学者）更容易理解。最后，我会将所有内容整合在一起，然后增加简洁性。

首先，需要更新 using 方法以使用 Try （同样，简洁性不是这里的目标）。它将被重命名为 tryUsingAutoCloseable：

def tryUsingAutoCloseable[A <: AutoCloseable, R]
  (instantiateAutoCloseable: () => A) //parameter list 1
  (transfer: A => scala.util.Try[R])  //parameter list 2
: scala.util.Try[R] =
  Try(instantiateAutoCloseable())
    .flatMap(
      autoCloseable => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(autoCloseable)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            autoCloseable.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

上面 tryUsingAutoCloseable 方法的开头可能会令人困惑，因为它似乎有两个参数列表，而不是通常的单个参数列表。这称为柯里化。我不会详细介绍柯里化的工作原理或它偶尔有用的地方。事实证明，对于这个特定的问题空间，它是完成这项工作的正确工具。

接下来，我们需要创建方法 tryPrintToFile，它将创建（或覆盖现有的）File 并写入 List[String]。它使用一个 FileWriter，它被一个 BufferedWriter 封装，而 BufferedWriter 又被一个 PrintWriter 封装。为了提高性能，定义了比 BufferedWriter 的默认值大得多的默认缓冲区大小 defaultBufferSize，并分配了值 65536。

这是代码（再次强调，简洁性是不是这里的目标）：

val defaultBufferSize: Int = 65536

def tryPrintToFile(
  lines: List[String],
  location: java.io.File,
  bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
  tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
    fileWriter =>
      tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
        bufferedWriter =>
          tryUsingAutoCloseable(() => new java.io.PrintWriter(bufferedWriter)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
            printWriter =>
              scala.util.Try(
                lines.foreach(line => printWriter.println(line))
              )
          }
      }
  }
}

上面的 tryPrintToFile 方法很有用，因为它采用 List[String] 作为输入并将其发送到 File 。现在让我们创建一个 tryWriteToFile 方法，该方法接受 String 并将其写入 File。

下面是代码（我会让你猜测这里简洁性的优先级）：

def tryWriteToFile(
  content: String,
  location: java.io.File,
  bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
  tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
    fileWriter =>
      tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
        bufferedWriter =>
          Try(bufferedWriter.write(content))
      }
  }
}

最后，能够以 String 的形式获取 File 的内容是很有用的。虽然 scala.io.Source 提供了一种方便的方法来轻松获取 File 的内容，但必须在 File 上使用 close 方法>Source 用于释放底层 JVM 和文件系统句柄。如果不这样做，那么资源不会被释放，直到 JVM GC（垃圾收集器）开始释放 Source 实例本身。即使这样，JVM 也只能保证 GC 会调用 Finalize 方法来关闭资源。这意味着显式调用 close 方法是客户端的责任，就像客户端有责任在 的实例上关闭 close 方法一样。 java.lang.AutoCloseable。为此，我们需要处理 scala.io.Source 的 using 方法的第二个定义。

这是它的代码（仍然不够简洁）：

def tryUsingSource[S <: scala.io.Source, R]
  (instantiateSource: () => S)
  (transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
  Try(instantiateSource())
    .flatMap(
      source => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(source)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            source.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

这是一个在超级简单的行流文件读取器中使用它的示例（当前用于从数据库输出中读取制表符分隔的文件）：

def tryProcessSource(
    file: java.io.File
  , parseLine: (String, Int) => List[String] = (line, index) => List(line)
  , filterLine: (List[String], Int) => Boolean = (values, index) => true
  , retainValues: (List[String], Int) => List[String] = (values, index) => values
  , isFirstLineNotHeader: Boolean = false
): scala.util.Try[List[List[String]]] =
  tryUsingSource(scala.io.Source.fromFile(file)) {
    source =>
      scala.util.Try(
        ( for {
            (line, index) <-
              source.getLines().buffered.zipWithIndex
            values =
              parseLine(line, index)
            if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
            retainedValues =
              retainValues(values, index)
          } yield retainedValues
        ).toList //must explicitly use toList due to the source.close which will
                 //occur immediately following execution of this anonymous function
      )
  )

上述函数的更新版本已作为对不同但相关的 StackOverflow 问题。

---

现在，将所有内容与提取的导入结合在一起（使其更容易粘贴到 Eclipse ScalaIDE 和 IntelliJ Scala 插件中存在的 Scala 工作表中，以便轻松将输出转储到桌面，以便更轻松地使用文本编辑器进行检查），这就是代码的样子（更加简洁）：

import scala.io.Source
import scala.util.Try
import java.io.{BufferedWriter, FileWriter, File, PrintWriter}

val defaultBufferSize: Int = 65536

def tryUsingAutoCloseable[A <: AutoCloseable, R]
  (instantiateAutoCloseable: () => A) //parameter list 1
  (transfer: A => scala.util.Try[R])  //parameter list 2
: scala.util.Try[R] =
  Try(instantiateAutoCloseable())
    .flatMap(
      autoCloseable => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(autoCloseable)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            autoCloseable.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

def tryUsingSource[S <: scala.io.Source, R]
  (instantiateSource: () => S)
  (transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
  Try(instantiateSource())
    .flatMap(
      source => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(source)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            source.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

def tryPrintToFile(
  lines: List[String],
  location: File,
  bufferSize: Int = defaultBufferSize
): Try[Unit] =
  tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
    tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
      tryUsingAutoCloseable(() => new PrintWriter(bufferedWriter)) { printWriter =>
          Try(lines.foreach(line => printWriter.println(line)))
      }
    }
  }

def tryWriteToFile(
  content: String,
  location: File,
  bufferSize: Int = defaultBufferSize
): Try[Unit] =
  tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
    tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
      Try(bufferedWriter.write(content))
    }
  }

def tryProcessSource(
    file: File,
  parseLine: (String, Int) => List[String] = (line, index) => List(line),
  filterLine: (List[String], Int) => Boolean = (values, index) => true,
  retainValues: (List[String], Int) => List[String] = (values, index) => values,
  isFirstLineNotHeader: Boolean = false
): Try[List[List[String]]] =
  tryUsingSource(() => Source.fromFile(file)) { source =>
    Try(
      ( for {
          (line, index) <- source.getLines().buffered.zipWithIndex
          values = parseLine(line, index)
          if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
          retainedValues = retainValues(values, index)
        } yield retainedValues
      ).toList
    )
  }

作为 Scala/FP 新手，我花费了很多时间（主要是令人头疼的挫败感）来获得上述知识和解决方案。我希望这可以帮助其他 Scala/FP 新手更快地克服这个特定的学习难题。

Answer 12

下面是使用 scalaz-stream 将一些行写入文件的示例。

import scalaz._
import scalaz.stream._

def writeLinesToFile(lines: Seq[String], file: String): Task[Unit] =
  Process(lines: _*)              // Process that enumerates the lines
    .flatMap(Process(_, "\n"))    // Add a newline after each line
    .pipe(text.utf8Encode)        // Encode as UTF-8
    .to(io.fileChunkW(fileName))  // Buffered write to the file
    .runLog[Task, Unit]           // Get this computation as a Task
    .map(_ => ())                 // Discard the result

writeLinesToFile(Seq("one", "two"), "file.txt").run

Answer 13

为了超越 samthebest 和他之前的贡献者，我改进了命名和简洁性：

  def using[A <: {def close() : Unit}, B](resource: A)(f: A => B): B =
    try f(resource) finally resource.close()

  def writeStringToFile(file: File, data: String, appending: Boolean = false) =
    using(new FileWriter(file, appending))(_.write(data))

Answer 14

无依赖项，带有错误处理

• 专门使用标准库中的方法
• 如有必要，为文件创建目录
• 使用 Either 用于错误处理

代码

def write(destinationFile: Path, fileContent: String): Either[Exception, Path] =
  write(destinationFile, fileContent.getBytes(StandardCharsets.UTF_8))

def write(destinationFile: Path, fileContent: Array[Byte]): Either[Exception, Path] =
  try {
    Files.createDirectories(destinationFile.getParent)
    // Return the path to the destinationFile if the write is successful
    Right(Files.write(destinationFile, fileContent))
  } catch {
    case exception: Exception => Left(exception)
  }

用法

val filePath = Paths.get("./testDir/file.txt")

write(filePath , "A test") match {
  case Right(pathToWrittenFile) => println(s"Successfully wrote to $pathToWrittenFile")
  case Left(exception) => println(s"Could not write to $filePath. Exception: $exception")
}

Answer 15

2019 更新：

总结 - Java NIO（或异步的 NIO.2）仍然是 Scala 支持的最全面的文件处理解决方案。以下代码创建一些文本并将其写入新文件：

import java.io.{BufferedOutputStream, OutputStream}
import java.nio.file.{Files, Paths}

val testFile1 = Paths.get("yourNewFile.txt")
val s1 = "text to insert in file".getBytes()

val out1: OutputStream = new BufferedOutputStream(
  Files.newOutputStream(testFile1))

try {
  out1.write(s1, 0, s1.length)
} catch {
  case _ => println("Exception thrown during file writing")
} finally {
  out1.close()
}

1. 导入 Java 库：IO 和 NIO
2. 使用您选择的文件名创建一个 Path 对象
3. 将要插入文件的文本转换为字节array
4. 将文件作为流获取： OutputStream
5. 将字节数组传递到输出流的 write 函数中
6. 关闭流

Answer 16

与这个答案类似，下面是一个fs2（版本1.0.4）的示例：

import cats.effect._

import fs2._
import fs2.io

import java.nio.file._

import scala.concurrent.ExecutionContext
import scala.language.higherKinds
import cats.syntax.functor._

object ScalaApp extends IOApp {

  def write[T[_]](p: Path, s: String)
                 (implicit F: ConcurrentEffect[T], cs: ContextShift[T]): T[Unit] = {
    Stream(s)
      .covary[T]
      .through(text.utf8Encode)
      .through(
        io.file.writeAll(
          p,
          scala.concurrent.ExecutionContext.global,
          Seq(StandardOpenOption.CREATE)
        )
      )
      .compile
      .drain
  }


  def run(args: List[String]): IO[ExitCode] = {

    implicit val executionContext: ExecutionContext =
      scala.concurrent.ExecutionContext.Implicits.global

    implicit val contextShift: ContextShift[IO] =
      IO.contextShift(executionContext)

    val outputFile: Path = Paths.get("output.txt")

    write[IO](outputFile, "Hello world\n").as(ExitCode.Success)

  }
}

Answer 17

import java.io.File
import java.io.PrintWriter

val file = new File("tmp/cloudwatch/metric.json")
val writer = new PrintWriter(file);
writer.write(stream);
writer.close();

为我工作

Answer 18

此行有助于从数组或字符串写入文件。

 new PrintWriter(outputPath) { write(ArrayName.mkString("")); close }

Answer 19

如果您的项目中无论如何都有 Akka Streams，它会提供一条简短的信息：

def writeToFile(p: Path, s: String)(implicit mat: Materializer): Unit = {
  Source.single(ByteString(s)).runWith(FileIO.toPath(p))
}

Akka docs > 流式文件 IO< /a>