How to read a text file in Java

• 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();
  }
}

• 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();
  }
}

• 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)

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.