How to write to a file in Scala?

Question

For reading, there is the useful abstraction `Source`. How can I write lines to a text file?

Accepted Answer

Edit 2019 (8 years later), Scala-IO being not very active, if any, Li Haoyi suggests his own library `lihaoyi/os-lib`, that he presents below.

June 2019, Xavier Guihot mentions in his answer the library `Using`, a utility for performing automatic resource management.

Edit (September 2011): since Eduardo Costa asks about Scala2.9, and since Rick-777 comments that scalax.IO commit history is pretty much non-existent since mid-2009...

Scala-IO has changed place: see its GitHub repo, from Jesse Eichar (also on SO):

The Scala IO umbrella project consists of a few sub projects for different aspects and extensions of IO. There are two main components of Scala IO:

- Core - Core primarily deals with Reading and writing data to and from arbitrary sources and sinks. The corner stone traits are `Input`, `Output` and `Seekable` which provide the core API. Other classes of importance are `Resource`, `ReadChars` and `WriteChars`.

- File - File is a `File` (called `Path`) API that is based on a combination of Java 7 NIO filesystem and SBT PathFinder APIs. `Path` and `FileSystem` are the main entry points into the 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)
```

Original answer (January 2011), with the old place for scala-io:

If you don't want to wait for Scala2.9, you can use the scala-incubator / scala-io library. (as mentioned in "Why doesn't Scala Source close the underlying InputStream?")

See the samples

```
{ // 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="||
||")(codec = Codec.UTF8)
  }
```

How to write to a file in Scala?

Solution

Problem

Related problems