[scala] 스칼라에서 파일에 쓰는 방법?

편집 2019 (8 년 이상), 스칼라-IO가 있는 경우, 매우 활성화되지되는 리튬 Haoyi가 자신의 라이브러리를 제안 lihaoyi/os-lib그가 것을, 아래에 제시한다 .

2019 년 6 월 Xavier Guihot 은 자신의 답변 에 Using자동 리소스 관리를 수행하는 유틸리티 인 라이브러리를 언급했습니다 .

편집 (2011 년 9 월) : Eduardo Costa 가 Scala2.9에 대해 질문 한 후 Rick-777 이 scalax.IO 커밋 기록 이 2009 년 중반 이후 거의 존재하지 않는다고 언급 한 이후로 …

스칼라-IO가 변경된 곳이 : 그 볼 GitHub의의의 repo 에서 제시 Eichar (또한 SO에를 )

Scala IO 우산 프로젝트는 IO의 다양한 측면과 확장을위한 몇 가지 하위 프로젝트로 구성됩니다.
스칼라 IO에는 두 가지 주요 구성 요소가 있습니다.

• 코어 -코어는 주로 임의의 소스 및 싱크에서 데이터를 읽고 쓰는 것을 처리합니다. 코너 스톤의 특징은 Input, Output하고 Seekable있는 핵심 API를 제공합니다.
  중요성의 다른 클래스는 Resource, ReadChars하고 WriteChars.
• File -File은 Java 7 NIO 파일 시스템과 SBT PathFinder API의 조합을 기반으로 하는 File(라 불리는 Path) API입니다.
  Path및 FileSystem스칼라 IO 파일 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)

scala-io의 이전 장소가 포함 된 원본 답변 (2011 년 1 월) :

Scala2.9를 기다리지 않으려면 scala-incubator / scala-io 라이브러리를 사용할 수 있습니다 .
( ” 스칼라 소스는 왜 기본 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)
  }

답변

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

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

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

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

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

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
}