Scalaでファイルに書き込む方法は？

Question

読み取りには、Sourceという便利な抽象化があります。テキストファイルに行を書き込むにはどうすればよいですか？

Answer 1

編集2019（8年後）、 Scala-IO あまりアクティブではない場合、 Li Haoyi は自分のライブラリを提案 lihaoyi/os-lib 、彼は 以下に表示 。

---

編集（2011年9月）： Eduardo Costa がScala2.9について質問し、 Rick-777 が scalax.IOコミット履歴 であるとコメントしているため2009年半ば以降はほとんど存在しません...

Scala-IOは場所を変更しました： GitHub repo を参照してください Jesse Eichar （また SO ）：

Scala IOアンブレラプロジェクトは、IOのさまざまな側面と拡張のためのいくつかのサブプロジェクトで構成されています。
Scala IOには2つの主要なコンポーネントがあります。

• コア-コアは主に、任意のソースとシンクからのデータの読み取りと書き込みを扱います。コーナーストーンの特性は、Input、Output、およびSeekableであり、これらはコアAPIを提供します。
  重要な他のクラスは、Resource、ReadChars、およびWriteCharsです。
• File-Fileは、Java 7 NIOファイルシステムとSBT PathFinder APIの組み合わせに基づくFile（Pathと呼ばれる）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ソースが基になる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 2

これは、標準のScalaにない機能の1つで、非常に便利なため、個人用ライブラリに追加しています。 （おそらく個人用ライブラリも必要です。）コードは次のようになります。

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

他の回答の編集が拒否されたため、別の回答を提供します。

これは、最も簡潔で簡単な答えです（ギャレットホールのものと同様）

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には中括弧もラムダも必要ないことに注意してください。プレースホルダー構文の使用に注意してください。また、より良い命名に注意してください。

Answer 6

Java.nioを使用して、Stringとの間で保存/読み取りを行うための1つのライナー。

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 7

以下は、Scalaコンパイラライブラリを使用した簡潔なワンライナーです。

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

または、Javaライブラリを使用する場合は、次のハックを実行できます。

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

From 1つのステートメントでファイルに文字列を書き込む

Answer 8

私が書いたマイクロライブラリ： https://github.com/pathikrit/better-files

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

または

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

Answer 9

Scalaでファイルを簡単に作成する方法に関するこれらの回答をすべて確認したところ、そのうちのいくつかは非常に素晴らしいものでしたが、3つの問題がありました。

1. Jus12's answer では、ヘルパーメソッドを使用するためのカリー化の使用は、Scala/FP初心者にとっては明白ではありません
2. scala.util.Tryで低レベルのエラーをカプセル化する必要があります
3. Scala/FPを初めて使用するJava開発者にdependentリソースを適切にネストする方法を示す必要があるため、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メソッドの始まりは、慣習的な単一のパラメーターリストではなく、2つのパラメーターリストがあるように見えるため、混乱する可能性があります。これはカレーと呼ばれます。そして、カレーがどのように機能するか、それがどこで時々役に立つかは詳しく説明しません。この特定の問題空間では、仕事に最適なツールであることがわかりました。

次に、メソッドtryPrintToFileを作成する必要があります。このメソッドは、Fileを作成（または既存の__name__を上書き）し、List[String]を記述します。 FileWriterによってカプセル化された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))
      }
  }
}

最後に、Fileの内容をStringとしてフェッチできると便利です。 scala.io.SourceはFileの内容を簡単に取得する便利なメソッドを提供しますが、closeメソッドをSourceで使用して、基礎となるJVMおよびファイルシステムハンドルを解放する必要があります。これが行われない場合、JVM GC（Garbage Collector）がSourceインスタンス自体を解放するまでリソースは解放されません。そして、それでも、GCによってfinalizeメソッドがリソースをcloseに呼び出されることを保証する弱いJVMのみがあります。これは、closeメソッドを明示的に呼び出すのはクライアントの責任であることを意味します。これは、Java.lang.AutoCloseableのインスタンスでクライアントがcloseを背負うことと同じです。このためには、scala.io.Sourceを処理するusingメソッドの2番目の定義が必要です。

このコードは次のとおりです（まだ簡潔ではありません）。

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

上記の関数の更新バージョン は、 異なるが関連する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)(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初心者がこの特定の学習ハンプをより早く乗り越えるのに役立つことを願っています。

Answer 10

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 11

残念なことに、トップの答えとして、Scala-IOは死んでいます。サードパーティの依存関係を使用しても構わない場合は、my OS-Lib library の使用を検討してください。これにより、ファイル、パス、ファイルシステムの操作が非常に簡単になります。

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

ファイルへの書き込み 、 ファイルへの追加 、 ファイルの上書き 、および他の多くの便利/一般的な操作のためのワンライナーがあります

Answer 12

とにかくプロジェクトにAkka Streamsがある場合、ワンライナーを提供します：

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

Akka docs> ストリーミングファイルIO

Answer 13

依存関係なし、エラー処理あり

• 標準ライブラリのメソッドのみを使用します
• 必要に応じて、ファイルのディレクトリを作成します
• エラー処理に 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 14

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. ファイルに挿入するテキストをバイト配列に変換します
4. ファイルをストリームとして取得します：OutputStream
5. バイト配列を出力ストリームのwrite関数に渡します
6. ストリームを閉じます

Answer 15

この答え と同様に、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 16

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 17

Scala 2.13を開始すると、標準ライブラリは専用のリソース管理ユーティリティ Using を提供します。

この場合、 PrintWriter または BufferedWriter などのリソースで使用できます。これは AutoCloseable を拡張し、ファイルに書き込むために、 、その後リソースを閉じます：

• たとえば、 Java.io api：

  import scala.util.Using
  import Java.io.{PrintWriter, File}
  
  // val lines = List("hello", "world")
  Using(new PrintWriter(new File("file.txt"))) {
    writer => lines.foreach(writer.println)
  }
  // scala.util.Try[Unit] = Success(())
  

• または Java.nio api：

  import scala.util.Using
  import Java.nio.file.{Files, Paths}, Java.nio.charset.Charset
  
  // val lines = List("hello", "world")
  Using(Files.newBufferedWriter(Paths.get("file.txt"), Charset.forName("UTF-8"))) {
    writer => lines.foreach(line => writer.write(line + "\n"))
  }
  // scala.util.Try[Unit] = Success(())
  

Answer 18

この行は、配列または文字列からファイルを書き込むのに役立ちます。

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