File input and output

Java reads a file with a Scanner and writes a file with a PrintStream. You know both already. A Scanner reads the keyboard, and System.out is a PrintStream. Opening a file can throw an exception the compiler makes you handle (a checked exception).

Scanner keyboard = new Scanner(System.in);    // reads the keyboard
File file = new File("scores.txt");
Scanner in = new Scanner(file);               // reads a file

System.out.println("hello");                  // writes to the console
PrintStream out = new PrintStream("report.txt");
out.println("hello");                         // writes to a file

You handle a checked exception by catching it in a try and catch, or by adding throws FileNotFoundException to the method header. Exception handling covers both. On the APE, catch it. The comment says to handle the exception, and a throws clause changes the method header, so the department's test no longer compiles.

These classes need import java.io.*; for File, PrintStream and FileNotFoundException, and import java.util.Scanner;.

Opening a file

When several methods share 1 open file, the stream (the Scanner or PrintStream object) lives in a static field, not in a local variable. A boolean field records whether the file is open, and a String field can record what went wrong. This class keeps 1 file for reading and 1 for writing.

public class ReportFile {
    public static Scanner reader;
    public static PrintStream writer;
    public static boolean readerOpen = false;
    public static boolean writerOpen = false;
    public static String status = "";

    public static boolean openForReading(String name) {
        File file = new File(name);
        try {
            reader = new Scanner(file);
        } catch (FileNotFoundException e) {
            status = "cannot read " + name;
            return false;
        }
        readerOpen = true;
        return true;
    }

    public static boolean openForWriting(String name) {
        try {
            writer = new PrintStream(name);
        } catch (FileNotFoundException e) {
            status = "cannot write " + name + ": " + e.getMessage();
            return false;
        }
        writerOpen = true;
        return true;
    }

    public static void closeAll() {
        if (readerOpen) {
            reader.close();
            readerOpen = false;
        }
        if (writerOpen) {
            writer.close();
            writerOpen = false;
        }
    }
}

• The try holds only the line that can throw.
• The flag becomes true only after the open succeeds. A failed open leaves it false.
• e.getMessage() is the text stored in the exception. For a PrintStream on a folder named reports, it holds the name and the system's reason. On macOS that is reports (Is a directory).
• new File(name) builds a path and does not touch the disk, so it succeeds for a name that does not exist. file.exists() asks the disk and returns true or false.

What close() does

close() ends the connection to the file and releases the file to the operating system. A PrintStream first flushes (writes out any data it still holds in memory), then closes the file. A Scanner closes the file it reads from. A closed stream cannot be opened again; open a new one instead.

After a close, the fields should match the file's state. The flag goes back to false, and some classes also set the stream field to null. The comment at the top of the problem lists every field to reset, and the test checks each one, including the message field.

Reading tokens

A Scanner splits its input into tokens (runs of characters separated by spaces, tabs or line breaks). A next method reads 1 token. A hasNext method checks the next token without reading it.

42 passes both tests, because a whole number can also be read as a double. So when a method tests for both types, it tests hasNextInt() first. Otherwise every whole number is read as a double.

This method adds up the int tokens and skips every other token.

public static int sumInts(Scanner in) {
    int sum = 0;
    while (in.hasNext()) {
        if (in.hasNextInt()) {
            sum = sum + in.nextInt();
        } else {
            in.next();    // skip a token that is not an int
        }
    }
    return sum;
}

Without in.next() in the else branch, the loop checks the same token forever, because hasNextInt() does not move past it. A Scanner can read a String as well as a file, so sumInts(new Scanner("4 x 5")) tests the method without a file and returns 9.

Writing with println

println(x) writes the text of x, then 1 line separator (the characters that end a line). For an object, the text is what its toString() returns, and for null it is the word null. The line separator is \r\n on Windows and \n on Linux and macOS.

out.println(42);            // writes 42, then a line separator
out.println("done");        // writes done, then a line separator
out.print("no newline");    // writes the text only

Adding "\n" yourself, as in out.println(text + "\n"), writes 2 line endings and leaves a blank line in the file.

Reading the Java API

The Java API documentation says what each class can do. To find out whether a Scanner can check the next token's type, open the Scanner page and read these parts in order.

1. The paragraph at the top says what the class is for. Scanner's says it breaks its input into tokens, separated by whitespace by default.
2. The constructor summary lists what a Scanner can read from. The File constructor is marked as throwing FileNotFoundException.
3. The method summary lists the methods by name. The hasNext methods pair with the next methods: hasNextInt with nextInt, hasNextDouble with nextDouble.
4. The method's own entry gives the details. hasNextInt returns whether the next token can be read as an int, and it does not move past the token.

In the practice APE

Practice exams 1 and 2 each have the same 6 file methods, in different folders. read, writeToOutputFile, closeInputFile and closeOutputFile use the public fields of the InputFile and OutputFile classes.

• The comment at the top of each file is the specification. It gives every message, every field to set and every value to return.
• Do the checks in the order the comment lists them. A null check has to come before any method call on the name, because name.equals("") on a null name throws a NullPointerException, not the exception the comment names.
• The openInputFile message ends with e.getMessage(), and the openOutputFile message does not. Copy each message as its own comment writes it.
• In Practice exam 1, the working copies in General/Files are source files you can read. Write your own open methods in General/Sorting before you look at them.
• In openInputFile, the comment shows 2 spaces after openInputFile: in the does-not-exist message. The department's test expects 1 space there, as in file name passed to openInputFile: I_do_not_exist.txt, does not exist.

Readiness check

Work each one on paper and write the answer down before you open the answers.

42 3.0 007 hi 12

PrintStream out = new PrintStream("t.txt");
out.print("a");
out.println("b");
out.println();
out.println(3 + 4);
out.println("x" + 3 + 4);
out.close();

ReportFile.openForReading("missing.txt");   // 1
ReportFile.openForWriting("out.txt");       // 2
ReportFile.writer.println("harbor");        // 3
ReportFile.closeAll();                      // 4
ReportFile.writer.println("again");         // 5

5
Ada Lovelace

int n = in.nextInt();
String name = in.nextLine();