How do I create a Java string from the contents of a file?

Legacy and prior to Java 11

For older Java versions or if you fancy classical methods, you may employ Files.readAllBytes and the String constructor:

byte[] bytes = Files.readAllBytes(Paths.get("file.txt"));  // Who needs a Bytebar when you have readAllBytes?
String content = new String(bytes, StandardCharsets.UTF_8); // String constructor, oldie but goldie.


Remember to handle IOException.

For juggernauts: large files

For memory management when dealing with large files, it's wise to avoid loading the entire content at once. Instead, use file streaming, treating it almost like a movie. Grab your popcorn!

try (Stream<String> stream = Files.lines(Paths.get("file.txt"), StandardCharsets.UTF_8)) {
    // Now showing: The Lines of Your File. One-time screening!
}


The try-with-resources statement reminds me of the old adage: clean your room before you leave!

Little files matter

When processing smaller files or files line by line, you can gather all lines into a list:

List<String> lines = Files.readAllLines(Paths.get("file.txt"), StandardCharsets.UTF_8);
String content = String.join("\n", lines);
// new String(lines)? Yikes, no such thing! Let's use join instead.


It's like a VIP concert where each line is a special guest, and they are joined by the "\n" host.

The chosen encoding

Coding is fun, but don't let it surprise you unexpectedly! Always specify the encoding explicitly. Can't go wrong with StandardCharsets.UTF_8.

byte[] bytes = Files.readAllBytes(Paths.get("file.txt"));
String content = new String(bytes, StandardCharsets.UTF_8);
// A brave UTF_8 journey!


The Scanner trick

The Scanner class can be transformed into a text-devouring beast, gobbling up the entire file:

Scanner scanner = new Scanner(new File("file.txt")); // Behold: the all-swallowing scanner!
scanner.useDelimiter("\\A");
String content = scanner.hasNext() ? scanner.next() : ""; // The scanner diet: one whole file. No leftovers!
scanner.close(); // Always remember to close the Scanner's mouth. No one likes a snorer.


This uses the "\\A" delimiter, which matches the beginning of the input and stretches till the end. Brace yourselves, the Scanner is coming!

Non-file data sources

In case your source isn't a file (gasp!), you might find BufferedReader quite welcoming:

try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("file.txt"), StandardCharsets.UTF_8))) {
    // Use reader.lines() to swim through a river of lines.
    // PS: No need to worry about the reader getting tired, it doesn't need rest.
}


This enables you to consume data from multiple sources, not just files.

When libraries are friends

The Apache Commons IO offers FileUtils for a friendly one-liner:

String content = FileUtils.readFileToString(new File("file.txt"), StandardCharsets.UTF_8);
// FileUtils: For when you need your file and String ASAP!


Use this if you're on friendly terms with external dependencies.

Handle with care: very large files

For files that are notoriously large, use BufferedReader and StringBuilder for memory-friendly operations:

try (BufferedReader br = new BufferedReader(new FileReader("largeFile.txt"))) {
    String line;
    StringBuilder sb = new StringBuilder();
    while ((line = br.readLine()) != null) {
        sb.append(line);
        sb.append(System.lineSeparator()); // I respect lines, they deserve to end with dignity
    }
    String content = sb.toString();
}


Error handling done right

Surround your file reading code within try-catch blocks to handle IOExceptions and ensure a smooth operation:

try {
    String content = Files.readString(Path.of("readMe.txt"), StandardCharsets.UTF_8);
    // Proceed with content...
} catch (IOException e) {
    e.printStackTrace();
    // Didn't expect this, did you? Welcome to the IOException land!
}
