Files, streams and object serialization

When a program closes, everything in the variables is lost. The way to make data permanent is to write it to a file. This week you work with two kinds of files: text files that a person can read, and binary files that store Java objects as they are. The most common exam topics: compile errors about checked exceptions (FileNotFoundException, IOException), the closing order of try-with-resources, Scanner loops, and transient in serialization.

Golden rules:

1. File operations throw checked exceptions. Either try/catch or throws IOException.
2. Close what you open. The safest way is try-with-resources; a writer that is not closed may not write the data to disk.
3. new FileWriter(file) erases the old content. To append, use new FileWriter(file, true).
4. The class to be serialized must be Serializable, and so must the objects it holds.
5. transient and static fields are not written to the file.

The stream concept

In Java, talking to a file happens through a stream: data flows byte by byte or character by character. There are two main families:

Path and Files

Path in the java.nio.file package represents the path of a file or folder. The Files class offers static helper methods.

Path scores = Paths.get("scores.txt");               // or Path.of("scores.txt")
System.out.println(Files.exists(scores) + " " + Files.exists(Paths.get("nope.txt")));
System.out.println(Files.isDirectory(dir) + " " + Files.isRegularFile(scores));
List<String> lines = Files.readAllLines(scores);
System.out.println(lines.size() + " " + lines.get(1));
System.out.println(scores.getFileName());
Path p2 = Paths.get("data", "2026", "notes.txt");
System.out.println(p2.getFileName() + " " + p2.getNameCount());
Files.write(Paths.get("w.txt"), List.of("one", "two"));
System.out.println(Files.readAllLines(Paths.get("w.txt")));

true false
true true
3 Mert 70
scores.txt
notes.txt 3
[one, two]

(scores.txt is the three-line file written in the previous example.) If a path is given as relative, it is looked up relative to the folder the program runs in; an absolute path is a full path like C:\....

Writing a text file

PrintWriter

It has the same methods as System.out: print, println, printf. The difference is that the output goes to a file instead of the screen.

try (PrintWriter out = new PrintWriter("scores.txt")) {
    out.println("Ece 85");
    out.println("Mert 70");
    out.printf("%s %d%n", "Can", 92);
}   // automatic close here: the data is written to disk

new PrintWriter("scores.txt") creates the file if it does not exist, and empties it if it does. If it cannot create it, it throws FileNotFoundException (checked).

What happens if you do not close?

PrintWriter leaky = new PrintWriter(new FileWriter("lost.txt"));
leaky.println("hello");
System.out.println(Files.size(Paths.get("lost.txt")));    // still in the buffer
leaky.close();
System.out.println(Files.size(Paths.get("lost.txt")) > 0);

0
true

Overwriting and appending

try (PrintWriter w = new PrintWriter(new FileWriter("log.txt"))) { w.println("first"); }
try (PrintWriter w = new PrintWriter(new FileWriter("log.txt"))) { w.println("second"); }
System.out.println(Files.readAllLines(Paths.get("log.txt")));
try (PrintWriter w = new PrintWriter(new FileWriter("log.txt", true))) { w.println("third"); }
System.out.println(Files.readAllLines(Paths.get("log.txt")));

[second]
[second, third]

Formatter

For formatted output, the format method uses the same format codes as printf. It is ideal for writing an aligned report like a table.

try (Formatter f = new Formatter("report.txt")) {
    f.format("%-6s|%5.1f|%03d%n", "Ada", 3.456, 7);
    f.format("%-6s|%5.1f|%03d%n", "Bora", 12.0, 42);
}

The lines of the file (the square brackets were added to make the spaces visible):

[Ada   |  3.5|007]
[Bora  | 12.0|042]

Reading a text file

With Scanner

You already know how to read from the keyboard; to read from a file, you give Scanner the file instead of System.in.

int total = 0, n = 0;
try (Scanner in = new Scanner(new File("scores.txt"))) {
    while (in.hasNext()) {
        String name = in.next();
        int score = in.nextInt();
        total += score; n++;
        System.out.println(name + " -> " + score);
    }
}
System.out.println("avg=" + (double) total / n);

Ece -> 85
Mert -> 70
Can -> 92
avg=82.33333333333333

If the file does not exist: new Scanner(new File(...)) throws FileNotFoundException, while Files.readAllLines throws NoSuchFileException (both are from the IOException family).

PITFALL · Scanner and the Turkish locale. Scanner reads numbers according to the computer’s locale. On a machine with Turkish settings, 5.5 is not counted as a decimal number, 5,5 is. In the test run, the average of the same file came out as 4.6250 in English settings and 4,3333 in Turkish settings. In the exam, assume the default English; in a real program, write in.useLocale(Locale.US).

Line by line with BufferedReader

try (BufferedReader br = Files.newBufferedReader(Paths.get("scores.txt"))) {
    String line;
    int count = 0;
    while ((line = br.readLine()) != null) count += line.length();
    System.out.println(count);
    System.out.println(br.readLine());     // end of file
}

19
null

readLine returns null when the file ends; the loop condition checks for this. (“Ece 85” is 6, “Mert 70” is 7, “Can 92” is 6 characters: 19.)

try-with-resources

The form try (Resource r = ...) { ... } automatically calls the resource’s close() method however the block ends. The resource must implement the AutoCloseable (or Closeable) interface; otherwise try-with-resources not applicable to variable type.

class Res implements AutoCloseable {
    private final String name;
    Res(String name) { this.name = name; System.out.println("open " + name); }
    void use() { System.out.println("use " + name); }
    @Override public void close() { System.out.println("close " + name); }
}

try (Res a = new Res("A"); Res b = new Res("B")) {
    a.use();
    b.use();
    throw new IllegalStateException("boom");
} catch (IllegalStateException e) {
    System.out.println("caught " + e.getMessage());
} finally {
    System.out.println("finally");
}

open A
open B
use A
use B
close B
close A
caught boom
finally

The order rule: opening is in the order written, closing is in reverse order, and closing happens before the catch. If close() also throws an exception, the exception in the body stays as the main exception, and the one from close is added to it as “suppressed”: in the test run e.getSuppressed()[0].getMessage() gave close failed.

Object serialization

Turning an object, together with all its fields, into a byte array and writing it to a file is called serialization; reading it back and rebuilding the object is called deserialization. The class must implement the java.io.Serializable interface. This interface has no methods at all; it only marks “this class can be written” (marker interface).

class Student implements Serializable {
    private static final long serialVersionUID = 1L;   // version number (recommended)
    String name; double gpa;
    transient String password;                         // not written
    static String school = "BAU";                      // not written (belongs to the class)
    Student(String n, double g, String p) { name = n; gpa = g; password = p; }
    public String toString() { return name + " " + gpa + " " + password; }
}

try (ObjectOutputStream oos = new ObjectOutputStream(Files.newOutputStream(Paths.get("students.ser")))) {
    oos.writeObject(new Student("Deniz", 3.4, "secret"));
    oos.writeObject(new Student("Ece", 3.9, "pw"));
    oos.writeInt(2026);
}
Student.school = "changed";
try (ObjectInputStream ois = new ObjectInputStream(Files.newInputStream(Paths.get("students.ser")))) {
    Student s1 = (Student) ois.readObject();    // returns Object, cast required
    Student s2 = (Student) ois.readObject();
    int year = ois.readInt();
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(year + " " + Student.school);
}

Deniz 3.4 null
Ece 3.9 null
2026 changed

The reading order must be the same as the writing order. readObject can throw two checked exceptions: IOException and ClassNotFoundException. If there is no object left to read in the file, EOFException comes.

Collections such as ArrayList are also Serializable (as long as the elements inside are Serializable too). You can write the whole list with a single writeObject. The list read back is a new object: in the test run back == names came out false and back.equals(names) came out true.

If the class of a field inside is not Serializable, NotSerializableException is thrown at write time; its message is the name of the problem class. This is a run-time error, the compiler does not catch it.

Common mistakes

public static void main(String[] args) {
    Scanner in = new Scanner(new File("data.txt"));
    System.out.println(in.nextLine());
}

try (PrintWriter out = new PrintWriter("scores.txt")) {
    out.println("Ece 85");
    out.println("Mert 70");
    out.printf("%s %d%n", "Can", 92);
}
int total = 0, n = 0;
try (Scanner in = new Scanner(new File("scores.txt"))) {
    while (in.hasNext()) {
        String name = in.next();
        total += in.nextInt();
        n++;
    }
}
System.out.println("avg=" + (double) total / n);

class Res implements AutoCloseable {
    private final String name;
    Res(String name) { this.name = name; System.out.println("open " + name); }
    public void close() { System.out.println("close " + name); }
}
// in main:
try (Res a = new Res("A"); Res b = new Res("B")) {
    System.out.println("body");
    throw new IllegalStateException("boom");
} catch (IllegalStateException e) {
    System.out.println("caught " + e.getMessage());
} finally {
    System.out.println("finally");
}

class Student implements Serializable {
    String name; double gpa;
    transient String password;
    Student(String n, double g, String p) { name = n; gpa = g; password = p; }
    public String toString() { return name + " " + gpa + " " + password; }
}
// write new Student("Deniz", 3.4, "secret") with ObjectOutputStream,
// then read it back with ObjectInputStream and print it

class Address { String city = "Istanbul"; }
class Person implements Serializable {
    String name = "Ali";
    Address address = new Address();
}
// oos.writeObject(new Person());

try (PrintWriter w = new PrintWriter(new FileWriter("log.txt"))) { w.println("first"); }
try (PrintWriter w = new PrintWriter(new FileWriter("log.txt"))) { w.println("second"); }
try (PrintWriter w = new PrintWriter(new FileWriter("log.txt", true))) { w.println("third"); }

// mixed.txt contains:  3 x 4
//                      5.5 6 end
int sum = 0;
try (Scanner in = new Scanner(Paths.get("mixed.txt"))) {
    while (in.hasNext()) {
        if (in.hasNextInt()) sum += in.nextInt();
        else in.next();
    }
}
System.out.println(sum);

try (Formatter f = new Formatter("report.txt")) {
    f.format("%-6s|%5.1f|%03d%n", "Ada", 3.456, 7);
    f.format("%-6s|%5.1f|%03d%n", "Bora", 12.0, 42);
}

static Object load(ObjectInputStream ois) throws IOException {
    return ois.readObject();
}

public static double averageOfFile(Path path) throws IOException {
    int count = 0;
    double sum = 0;
    try (Scanner in = new Scanner(path)) {
        while (in.hasNext()) {
            if (in.hasNextDouble()) {
                sum += in.nextDouble();
                count++;
            } else {
                in.next();
            }
        }
    }
    return count == 0 ? 0 : sum / count;
}