# Java Read Text File to String Using NIO Files API

> Use Files.readString for small files or Files.lines for streaming large files in modern Java, with a BufferedReader fallback for older codebases

**URL:** https://sentry.io/answers/read-a-plain-text-file-in-java/

---

## The Problem

What is the best way to read a plain text file in modern Java?

## The Solution

To read the entire contents of a file into a single `String` variable, you can use the [`Files.readString`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/file/Files.html#readString(java.nio.file.Path)) method. The method was introduced in Java 11 and is a good way of handling small files. For example, the code below reads the text of `myfile.txt` and prints it:

```java
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class ReadFile {
    public static void main(String[] args) {
        Path filePath = Paths.get("myfile.txt");
        try {
            String content = Files.readString(filePath);
            System.out.println(content); // print entire file content
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
```

For larger files, or files where we want to process each line separately rather than reading the whole thing in at once, you can use [`Files.lines`](https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#lines-java.nio.file.Path-), which  was introduced in Java 8. It returns a `Stream<String>` object. Here's another version of the file-reading code:

```java
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.stream.Stream;

public class ReadFile {
    public static void main(String[] args) {
        Path filePath = Paths.get("myfile.txt");
        try (Stream<String> lines = Files.lines(filePath)) {
            lines.forEach(System.out::println); // print each line
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
```

Code written in older versions of Java will often use a [`BufferedReader`](https://docs.oracle.com/javase/8/docs/api/java/io/BufferedReader.html) and a [`FileReader`](https://docs.oracle.com/javase/8/docs/api/java/io/FileReader.html) to read files. This class has been available since Java 1.1 and offers more control over how the file is read. For example, you can use the `read` and `skip` methods to read four characters from the start of the file, skip the next six characters, and then read another five characters. You can also read the file line by line, as we did above with `File.lines`. For example:

```java
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile {
    public static void main(String[] args) throws FileNotFoundException { // must throw FileNotFoundException when using FileReader

        String path = "myfile.txt";
        BufferedReader reader = new BufferedReader(new FileReader(path));
        try {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line); // print each line until the end of the file
            }
        } catch (IOException e) {
            e.printStackTrace(); // print error if file reading fails
        } finally {
            try {
                if (reader != null) { // close the BufferedReader and free the memory it used
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
```

When writing modern Java, the first two methods should be preferred. The `BufferedReader` method will be encountered in older codebases and can still be used when necessary for either backward compatibility or increased control over the file reading process.

---

*Source: [sentry.io/answers/read-a-plain-text-file-in-java/](https://sentry.io/answers/read-a-plain-text-file-in-java/)*