Это одна из функций, отсутствующих в стандартном 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)
}

Как и ответ Рекса Керра, но более общий. Сначала я использую вспомогательную функцию:

/**
 * 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)
    }
  }

и др.

Простой ответ:

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()
  }

Дайте другой ответ, потому что мои правки других ответов отклоняются.

Это самый сжатый и простой ответ (похожий на Garret Hall's)

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 или lambdas, а также использование синтаксиса placeholder. Также обратите внимание на лучшее именование.

Один вкладыш для сохранения/чтения в/из String, используя java.nio.

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

Ниже приведен краткий однострочный файл с использованием библиотеки компилятора Scala:

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

В качестве альтернативы, если вы хотите использовать библиотеки Java, вы можете сделать этот взлом:

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

От scala записать строку в файл в одном утверждении

Микробиблиотека, которую я написал: https://github.com/pathikrit/better-files

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

или

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

После просмотра всех этих ответов о том, как легко записать файл в Scala, а некоторые из них довольно приятные, у меня было три проблемы:

• В ответе Jus12 использование currying для использования вспомогательного метода неочевидно для Scala/FP beginners
• Необходимо инкапсулировать ошибки нижнего уровня с помощью scala.util.Try
• Нужно показать разработчикам Java, новым для Scala/FP, как правильно вложить зависимые ресурсы, чтобы метод 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 =>
        try
          transfer(autoCloseable)
        finally
          autoCloseable.close()
    )

Начало вышеуказанного метода tryUsingAutoCloseable может быть запутанным, потому что у него есть два списка параметров вместо обычного списка одиночных параметров. Это называется каррирование. И я не буду вдаваться в подробности, как работает каррирование или где это иногда полезно. Оказывается, что для этого конкретного проблемного пространства это правильный инструмент для задания.

Далее нам нужно создать метод tryPrintToFile, который создаст (или перезапишет существующий) File и напишет a List[String]. Он использует FileWriter, который инкапсулирован a BufferedWriter, который, в свою очередь, инкапсулируется a 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))
      }
  }
}

Наконец, полезно иметь возможность извлекать содержимое File в качестве String. В то время как scala.io.Source обеспечивает удобный способ для легкого получения содержимого a File, метод close должен использоваться в Source для освобождения основных JVM и дескрипторов файловой системы. Если этого не сделать, ресурс не будет выпущен до тех пор, пока JVM GC (Garbage Collector) не начнет выпускать сам экземпляр Source. И даже тогда, существует только слабая гарантия JVM, метод finalize будет вызываться GC для close ресурса. Это означает, что ответственность клиента за явное обращение к методу close заключается в том, что клиент отвечает на высокий close на экземпляр java.lang.AutoCloseable. Для этого нам нужно второе определение метода использования, который обрабатывает scala.io.Source.

Вот код для этого (еще не краткий):

def tryUsingSource[S <: scala.io.Source, R]
  (instantiateSource: () => S)
  (transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
  Try(instantiateSource())
    .flatMap(
      source =>
        try
          transfer(source))
        finally
          source.close()
    )

И вот пример использования его в супер-простое устройство для потоковой передачи строк (в настоящее время используется для чтения файлов с разделителями табуляции из вывода базы данных):

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
      )
  )

обновленная версия вышеуказанной функции была предоставлена ​​в качестве ответа на https://stackoverflow.com/questions/501090/how-do-i-convert-a-decimal-to-an-int-in-c.

Теперь, приведя все это вместе с импортированным извлечением (упрощая вставку в Scala Рабочий лист, присутствующий в плагине Eclipse ScalaIDE и IntelliJ 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)(transfer: A => scala.util.Try[R]): scala.util.Try[R] =
  Try(instantiateAutoCloseable())
    .flatMap(
      autoCloseable =>
        try transfer(autoCloseable)) finally autoCloseable.close()
    )

def tryUsingSource[S <: scala.io.Source, R]
  (instantiateSource: () => S)(transfer: S => scala.util.Try[R]): scala.util.Try[R] =
  Try(instantiateSource())
    .flatMap(
      source =>
        try transfer(source)) finally source.close()
    )

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 быстрее справляться с этим конкретным учебным горбом.

Здесь приведен пример записи некоторых строк в файл с помощью 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

Без зависимостей, с обработкой ошибок

• Использует только методы из стандартной библиотеки
• Создает каталоги для файла, если необходимо
• Использует 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")
}

Чтобы превзойти 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))

Если вы в любом случае имеете Akka Streams в своем проекте, он предоставляет однострочный:

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

Akka docs> Streaming File IO

Эта строка помогает записать файл из массива или строки.

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