Input & Output (I/O)l - 1

COMP122 Labs 2021-04-27

Due to the large number of I/O classes in java.io.Files, there is a class called:

java.nio.Files

This class consists of several static function calls that cater to common use cases.

You should look in this class before looking elsewhere.

Reading from File

A classic approach to reading from a text file uses a BufferedReader to read the file line by line, and looks something like this:

File file = new File(filePathAsString);
try(BufferedReader br = Files.newBufferedReader(file.toPath())) {
    String str = "";
    while ((str = br.readLine()) != null) {
        //do some logic with str
    }
} catch(IOException ioe) {
    throw ioe;
}

1. The first line of this code creates a java.io.File class from a file path String (e.g. “myDirectory/myFile.txt”).

2. The second line uses the Files.newBufferedReader method to instantiate a BufferedReader. It takes as its first argument the Path object associated to a file, and then allows for optional parameters that alter things like the character set. We omit these so it will have default settings and character set, UTF-8. This line is an example of try with resources, which is syntactic sugar for a lengthy try/catch construct.

   By declaring br inside the try, we ensure that it will be closed, which prevents resource leaks. If we didn’t use try with resources, we’d need to call br.close() in a finally block.

3. The third line just initializes an empty String.

4. The strange looking fourth line tries to read the next line of the file into str using BufferedReader’s readLine method. Once this operation is performed, the result of that assignment is null checked, and if str has become null we know we’ve reached the end of the file. So, this is just a loop that says read every line in as a String until the end of file.

   readLine() discards the trailing newline (\n), so if you wanted to reproduce the file’s content exactly you would need to add this back to the string.

5. The code enclosed by the while loop is where you would do your logic using the newly read str. There is then a catch block that throws an IOException if the BufferedReader runs into one.

The code above is a perfectly functional way to handle file I/O, but java.nio.file.Files offers a couple of simpler alternatives to cover this use case.

Using java.nio.file.Files

Lines as an ArrayList

The first, and what is probably most useful, is Files.readAllLines(path), which returns a List of every line, in order. That looks like this:

File file = new File(filePathAsString);
ArrayList<String> yourList = (ArrayList<String>) Files.readAllLines(file.toPath());

In two lines of code we now have every line of the file, ordered, in an ArrayList we can traverse with a simple for loop. This code practically is just a tidier repackaging of the code above, where the inner loop adds str to a List<String> initialized as empty before the try.

Original File as String

Another two-liner if you just want the whole file as one big String with the white space and new lines of the file preserved, is given below:

File file = new File(filePathAsString);
String yourFilesContent = Files.readString(file.toPath());

Both the readAllLines and readString methods throw IOExceptions. This is a checked exception type so you need to throw or catch them (as in the initial example).

These methods are not performance optimised, so if you need to read a very large file in a performance intensive setting (e.g. developing an industry strength library) these aren’t the way to go. However, in most cases both are fine.