How to read a file into a string in Java: under the hood analysis

How to read a file into a string in Java: analysis of a popular Stack Overflow question

If you have ever asked yourself "How do I create a Java string from the contents of a file?" — you are not alone. This question has garnered thousands of views on Stack Overflow, and for good reason. A seemingly trivial operation — reading a text file and placing its contents into a string — hides many pitfalls: from memory leaks to encoding issues.

In this article, we will not just provide ready-made recipes. We will look under the hood of each method: how BufferedReader works, why Files.readString() only appeared in Java 11, and how Scanner differs from InputStream. Let's go!

Why is it more complicated than it seems?

At first glance, the task is trivial: there is a file, there is a string. But Java is a language with strong typing and managed memory. To read a file, you need to:

\n
• Open a data stream (InputStream, Reader)
\n
• Buffer the reading (to avoid hitting the disk for every byte)
\n
• Collect bytes/characters into a single buffer
\n
• Convert to a string considering the encoding
\n
• Close resources (to avoid file descriptor leaks)
\n

Each of these steps is a potential point of failure. Let's break down the most popular approaches.

Method 1: The Classic — BufferedReader (Java 1.1+)

The oldest and most proven method. It uses BufferedReader for line-by-line reading. Under the hood, a buffer (default 8 KB) accumulates data, reducing the number of read() system calls.

public static String readFileBufferedReader(String filePath) throws IOException {\n    StringBuilder content = new StringBuilder();\n    try (BufferedReader reader = new BufferedReader(new FileReader(filePath, StandardCharsets.UTF_8))) {\n        String line;\n        while ((line = reader.readLine()) != null) {\n            content.append(line).append(System.lineSeparator());\n        }\n    }\n    return content.toString();\n}

How does this work under the hood?

FileReader opens the file and creates a FileInputStream. BufferedReader wraps it, adding a buffer. When readLine() is called, a block of data (e.g., 8 KB) is read, and the line is assembled from the buffer. If the line is longer than the buffer, the buffer is re-read. try-with-resources guarantees the stream is closed even on an exception.

Pros: Works on any version of Java, controlled line-by-line reading.
\nCons: Adds an extra line separator at the end, inefficient for huge files (string in memory).

Method 2: Scanner — convenient but slow (Java 5+)

Many people love Scanner for its simplicity. It can split input into tokens, but for reading an entire file it is used like this:

public static String readFileScanner(String filePath) throws IOException {\n    try (Scanner scanner = new Scanner(new File(filePath), StandardCharsets.UTF_8.name())) {\n        scanner.useDelimiter("\\\\A"); // Beginning of file as delimiter\n        return scanner.hasNext() ? scanner.next() : "";\n    }\n}

The magic of \\\\A: This is a regular expression denoting the beginning of the input data. By setting it as the delimiter, we force Scanner to read the entire content at once. Under the hood, Scanner uses Pattern to find the delimiter, which adds the overhead of regular expressions.

Pros: Very concise code.
\nCons: Slower than BufferedReader due to regex processing, not suitable for binary files.

Method 3: Files.readAllLines() — convenience of Java 8 (NIO)

Starting with Java 8, the java.nio.file package offered an elegant