How to read a text file in Java

In order to follow below examples, create a text file (sample.txt) with below content.

Hello, it's a great day today!

Method 1- read text files using java.nio.Files utility class
Method 2 - read text files using using java.io.FileReader class
Method 3- read text files using using java.io.BufferedReader class

using java.nio.Files

java.nio.Files is an utility class, which has lot of static methods that operate on files, in the below example we are going to use Files.lines(Path) method which returns Stream of Strings, each String represents a line in file. Alternatively we can use Files.readAllLines(Path) as well, which returns List of Strings, where each String represents a line from input file.

public static void readFile() { try { Stream<String> lines = Files.lines(Path.of("/path/to/sample.txt")); lines.forEach(System.out::println); } catch (IOException ioException){ ioException.printStackTrace(); } }

using java.io.FileReader

FileReader reads content of a file as a stream of characters from the file, and this class mainly intended for reading the data as text only.
It is possible to read one character at a time or an array of characters in each read method call, both examples are shown below.

public static void readFile() { File inputFile = new File("/path/to/sample.txt"); try(FileReader fileReader = new FileReader(inputFile)) { int ch; // fileReader.read() will return -1 if there is nothing left to read while((ch = fileReader.read()) != -1) { System.out.print((char)ch); } } catch (Exception ex) { ex.printStackTrace(); } }

In the above code, fileReader.read() method returns the character that it read, and when it reached end of file it returns -1.

We can also read an array of characters in one go, and in this example we are reading 1024 characters at a time and continuing until it reaches end of file.

public static void readFile() { try(FileReader fileReader = new FileReader("/path/to/sample.txt")) { StringBuilder sb = new StringBuilder(); char[] text = new char[1024]; int count; while((count = fileReader.read(text)) != -1) { sb.append(text, 0, count); } System.out.println(sb.toString()); } catch(Exception e) { e.printStackTrace(); } }

In the above code, FileReader.read(char[]) reads specified number of characters into the character array and returns how many characters were read and filled, when it reached end of file it returns -1.

using java.io.BufferedReader

BufferedReader expects another java.io.Reader as an input argument and the actual I/O operations such as reading from source file will be delegated to this underlying Reader class.
BufferedReader maintains a character array as a buffer in the memory to store chunks of characters data, so for any read request, it will return the data from the buffer as long as it has data and if it is empty then it reads the data from underlying source and fill the buffer. The default buffer size is 16KB, using this intermediate buffer it reduces number of I/O operations to the underlying source.
BufferedReader comes handy if you want to read input from files or sockets or any other source and it is thread-safe (synchronized)

To obtain BufferedReader instance, we could also use this utility method

public static void readFile() { try (BufferedReader br = new BufferedReader(new FileReader("/path/to/sample.txt"))) { String line; while((line = br.readLine()) != null) { System.out.println(line); } } catch (Exception ex) { ex.printStackTrace(); } }

In the above code, BufferedReader.readLine() method reads and returns one line at a time until it reaches end of file, and returns null when it reaches end of file.

Above examples source code can be found at GitHub link for Java code and JUnit tests can be found at GitHub link for Unit tests code

Similar Articles