Writing files

In reading files you opened a file and read what was already there. Reading is only half the story. The other half makes a program feel real: writing your own text to a file, so that it is still there after the program ends, after the window closes, even after the computer is switched off.

Why a file at all? Because variables forget#

Everything you have printed so far went to the console with System.out.println. That text scrolls past and is gone. Every variable you have made lives in memory, and memory is wiped clean the moment the program ends. Run the program again tomorrow and it remembers nothing about today.

A file lives on the disk instead. When you write text into a file, that text stays on the disk after main returns, after the JVM shuts down, after you close your laptop. The next program to run can open the same file and read it back. Making data survive past the life of the program that produced it is called persisting it.

Key idea

Console output is for a person to glance at and forget. A file is for data you want to keep. Writing to a file is how a program leaves something behind.

The smallest write: FileWriter#

The plainest tool for writing text is FileWriter. You give it a file name, you call write with some text, and you close it. Here is the whole thing:

Run it and nothing appears in the console. Look in the memory view instead: the Files section now holds greeting.txt, with Hello, file. inside. Read the program line by line. new FileWriter("greeting.txt") opens a file by that name for writing, and creates it if it does not exist yet. writer.write("Hello, file.") hands the text over to be written. writer.close() finishes the job and lets go of the file.

The imports bring in the two classes, as they did for reading, and throws IOException on main is there for the same reason as before: writing can fail. The disk might be full, the folder might be read-only, or the name might point into a folder that does not exist.

Wrapping it: BufferedWriter#

When you read files, you wrapped a FileReader inside a BufferedReader so you could read a whole line at a time and so it ran faster. Writing has the mirror image: you wrap a FileWriter inside a BufferedWriter.

A buffer is a holding area in memory. Instead of sending each small piece of text to the disk the instant you write it, the BufferedWriter gathers your text in memory and sends it to the disk in one larger batch. Touching the disk is slow, so doing it once with a big chunk is far cheaper than doing it a hundred times with small ones.

Step through it and watch the Files section. names.txt appears, empty, as soon as the file is opened. Each write and newLine only puts text into the buffer, and the file stays empty. Then close() runs, and all three names reach the file at once.

Two more things to notice. First, the wrapping: new BufferedWriter(new FileWriter("names.txt")) reads from the inside out. The FileWriter is built first and knows about the file; the BufferedWriter goes around it and adds the buffering. You then talk only to the outer BufferedWriter.

Second, newLine. The write method does not move to a new line by itself. Three write calls in a row with no newLine would give AishaBenCarmen, all jammed together on one line. out.newLine() adds a line break, so each name lands on its own line. It is the writing counterpart of pressing Enter.

Overwrite or append: the one-argument question#

Here is the most common surprise in file writing. When you open a file with new FileWriter("report.txt"), Java throws away whatever was already in that file and starts from empty. This is called overwriting, or truncating. The old contents are gone before you write a single character.

Often that is what you want. Sometimes, though, you want to add to a file and keep what was there: a running log, or a list you build up over many runs. For that you pass a second argument, true, which switches the file writer into append mode. In append mode, new text is added at the end and the old contents stay put.

Overwrite mode#

Before this program runs, report.txtholds Sunday's report, shown under the code. The program opens the file without a second argument and writes Monday's:

Report for Sunday
Sales: 9

Step through it and watch report.txt. On line 7, the moment the file is opened, Sunday's report vanishes and the file is empty. After close()it holds only Monday's two lines. Run the same program tomorrow and you get the same two lines again, never four.

Append mode#

Now the same idea with true. Each call to addEntry below opens log.txt in append mode, adds one line and closes the file, the same as one run of a program that logs a single line. The log starts with one line from Sunday:

Sunday: opened

Because of the true, Sunday's line stays, and each call adds one more line at the bottom. The log ends with three lines and keeps growing every time something is added. That one extra argument, true, is the whole difference between a fresh report and a growing log.

It prints three and four. two was appended after one, but the third save opens the file without appending, which wipes both. four is then appended after three.

flush and close: getting the buffer onto the disk#

A BufferedWriter holds your text in memory and only sends it to the disk in batches. That speed trick has a sharp edge. If the program ends while text is still sitting in the buffer, that text never reaches the file. It is simply lost, and no error tells you so. This program writes two names and forgets to close the writer:

The console says Wrote two names., and every write ran without an error. Now look at the Files section: names.txt exists, because opening it created it, but it is empty. The narration on the last step explains why: the program ended while out still held the names in its buffer. Open the program full screen, add out.close(); as the last line of main, and run it again to see the names arrive.

Two methods control when the buffer empties. flush pushes whatever is in the buffer out to the file right now and keeps the file open, so you can keep writing. close flushes for you and then releases the file, after which you can no longer write to it. Writing after close() throws an IOException with the message Stream closed.

Key idea

close is the call that guarantees your buffered text lands in the file. Skip it and the text can vanish without a single error message.

When would you flush instead of close?#

Use flush when you want the text in the file now, but you are not finished writing. A program that writes a log line every few seconds for hours wants each line safely on disk soon after it is written, in case the program crashes later. It does not want to close the file, because it has more to write. So it flushes after each line and closes only at the very end.

Only log.txt: Started appears. The flush() on line 12 pushed Started into the file. Working went into the buffer afterwards and was still waiting there when the reader looked, and because out is never closed, it never reaches the file at all.

Letting try-with-resources close for you#

It is easy to forget close, especially if an error jumps you out of the method before you reach it. You met the fix when reading files: try-with-resources. Declare the writer inside parentheses right after try, and Java closes it for you when the block ends, whether it ends normally or because of an error. Because close flushes, this also guarantees that your buffer reaches the file.

There is no out.close() anywhere in that code, and yet the file is flushed and closed. Step to the end: the narration says out is closed automatically, and the three lines appear in report.txt at that moment. This is the form to reach for by default.

The lines are ordinary strings built with +, the same string joining you have used all along. A file does not care that items is an int and total is a double. Once they are joined into a String, write puts those characters in the file. The double 1260.0 comes out with its trailing .0, as it would on the console.

After the run, count.txt holds * on the first line and 42 on the second.

PrintWriter: println for files#

Writing every line as a write followed by a newLine gets repetitive. A PrintWriter wrapped around a FileWriter gives a file the same print and println methods that System.out has, so anything you know how to print to the console, you can print to a file:

This writes Ada 91, Grace 88 and Alan 79, one per line: the same scores.txt that the reading files lesson read back and averaged. printlnends each line with the system's line ending, like newLine(), and a PrintWriter needs closing like any other writer, which the try-with-resources block does.

Save, then load#

Persisting data means a program can find tomorrow what it saved today. The program below saves a to-do list, then opens the same file with the reader from the reading files lesson and prints what it finds. Trace how each write and newLine becomes one line of the file, and then one line of output.

The first write puts the heading To do on line one. The loop runs three times, once per task, and each time it writes a dash, a space, the task, and a line break. When the first try block ends, the writer is closed and the four lines are in todos.txt. The second block reads them back, so the console shows the heading and the three dashed lines.

1. 1Open the file for writing, choosing overwrite (the default) or append (true).
2. 2Wrap it in a BufferedWriter or a PrintWriter.
3. 3Call write and newLine, or println, for each line.
4. 4Let close run, through try-with-resources, so the buffer reaches the file.

1import java.io.BufferedReader;
2import java.io.BufferedWriter;
3import java.io.FileReader;
4import java.io.FileWriter;
5import java.io.IOException;
6 
7public class Main {
8    public static void main(String[] args) throws IOException {
9        try (BufferedWriter out = new BufferedWriter(new FileWriter("table.txt"))) {
10            // TODO: write the lines 3 x 1 = 3 up to 3 x 5 = 15, one per line
11        }
12 
13        // Reads table.txt back so you can check it
14        try (BufferedReader in = new BufferedReader(new FileReader("table.txt"))) {
15            String line = in.readLine();
16            while (line != null) {
17                System.out.println("> " + line);
18                line = in.readLine();
19            }
20        }
21    }
22}

Further reading#

• FileWriter in the Java SE 25 API documentation, including the constructor with the append argument
• BufferedWriter in the Java SE 25 API documentation, with newLine, flush and close
• PrintWriter in the Java SE 25 API documentation, including checkError