Reading a file in Java (java.io)

Reading a files is a highly common task in any object-oriented programming language. Particularly, The Java Development Kit (JDK) comes with Input-Output (IO) libraries to fulfill these goals: java.io and the Non-Blocking IO (Aka, New I/O), java.nio. The variety of methods provided in these libraries are meant to be used according the complexity of the resource to be read: from small files to rather large text files and advanced features like file-locking (java.nio). You can check out this post if you want to learn more about the JAVA NIO capabilities for reading files.

Depending on which library we intend to use, there are actually different ways (techniques) to read chars from a stream of bytes.

Java views each file as simple a stream of bytes. We can define a stream (computer-wise) as a sequence of bytes. In any input operation the stream (sequence) flows from a device (the keyboard, a disk drive, etc.) to the computer’s main memory; while in an output operation the stream flows from main memory to a device (a display screen, a network connection, a network drive, a printer, etc.).

It is important to mention that file streams in Java can be used to input and output data either as bytes or characters. On one hand, a binary-based stream inputs and outputs data in binary form (i.e.: Writing the value 5 in a byte-based stream would input said value in its binary form, which is 101). On the other hand, character-based streams input and output data as a sequence of characters.

The Standard Stream Objects in Java

In Java, when any program is set to run (begins execution), there are three stream objects that come into play. Each stream object is a associated with devices. First, the System.in, which is the standard input stream object; is normally associated with the computer’s keyboard, thus enabling any program utilizing it to input bytes from the keyboard. Second, we have the System.out, which is the standard output stream object; enables a program to output characters to the display screen. And finally, the System.err, the standard error stream object, which just as the the System.out, it enables a program to output character-based error messages to the computer’s screen. However, each stream can be redirected; meaning, that we can force the stream object to input/output setting a different source to it. For instance, we can make System.out to output (send) its result to a file on an external disk.

Reading a file using the Java Scanner

Besides the java.io package, which enables us to perform lots of input-output operations, just as mentioned lines above. Java has a utility class named Scanner (in java.util). Scanner class is typically used to input data from the keyboard to the display screen; however, it can also be used to read from a file. The following is an example of how we can use this Scanner class to perform a read operation from an existing file. Besides file reading, Scanner has some other features described on this post.

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

/*
Author: Gustavo Luque
ReadingInBits, 2020
*/
public class ReadWriteFileExample {

    private Scanner scanner;

    public static void main(String[] args) {
        ReadWriteFileExample example = new ReadWriteFileExample();
        example.openAndReadFile("Sample.txt");
    }

    private void openAndReadFile(String fileName){
        try {
            //We set the source of the Scanner utility to be a file in disk.
            scanner = new Scanner(new File(fileName));

            //Then we read until the file has no remaining lines to be read
            while (scanner.hasNext()){
                String line = scanner.nextLine();
                //Output each line to the screen
                System.out.println(line);
            }

        } catch (FileNotFoundException e) {
            System.err.println("File " + fileName + " does not exist");
            System.exit(1);
        }
        finally {
            //make sure we close the file
            if(scanner != null){
                scanner.close();
            }
        }
    }
}

One line 21 we set the source of the Scanner instance to be the File named Sample.txt, which must be located in the same directory as the compiled class (ReadWriteFileExample.class).

java.io is the package that contains all the required classes and interfaces for a program to perform file processing operations. This package includes the definition of the stream classes: FileInputStream (used for byte-based input from a file), FileOutputStream (for byte-based output to a file), FileReader (for character-based input from a file) and FileWriter (for character-based output to a file). These last two inherit from InputStream and OutputStream, which inherit from abstract the classes Reader and Writer, respectively.

Using FileInputStream

Let’s simply modify our method openAndReadFile to use FileInputStream:

private void openAndReadFile(String fileName) {
	try {

		//Read the file as a stream of bytes
		fis = new FileInputStream(new File(fileName));
		int b;
		while ((b = fis.read()) != -1){
			//We force the output to print the char representation of the read byte
			System.out.print((char) b);
		}
	} catch (FileNotFoundException fnfe) {
		System.err.println("File " + fileName + " does not exist");
	} catch (IOException ioe){
		ioe.printStackTrace();
	}
	finally {
		//make sure we close the file
		if(fis != null){
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Notice how we use a while loop to read the entire file. read()method reads every byte in the file until the end is reached (-1 is returned). Then we print out the each byte as a character using the int to char casting. Indeed, it is not optimal to use FileInputStream to read a character-based stream. For that purpose we have FileReader.

Using a FileReader in a BufferedReader

This class is meant for reading a stream of characters from a file (character-based input). As explained in the Java API documentation and also here in this post, wrapping a FileReader object into a BufferedReader will increase program’s reading/writing efficiency, thus allowing the reading on large files as opposed to the un-buffered way previously explained with FileInputStream.

NOTE:
Prior to Java SE 7, a finally block would be used to ensure execution of code within (typically closing a file stream resource). As per Java SE 7+, in order to release system resource, programmers may use a try-with-resources statement. The following examples will use this statement for practical educational purposes.

private void readStuff(){

        try (BufferedReader br =
                     new BufferedReader(
                             new FileReader("D:\\data\\employees.xml"))){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        }catch (IOException ioe){
            System.err.println("Unexpected: " + ioe.toString());
        }
    }

The method above simply reads each line from the text file and prints it out on screen.