Read Resource Text File to String in Java

java

file-io

java-nio

exception-handling

byAnton Shumikhin·Sep 23, 2024

To swiftly convert a resource text file to a String, count on Java NIO's Files and Paths API:

String result = new String(
    Files.readAllBytes(Paths.get(getClass().getClassLoader().getResource("yourTextFile.txt").toURI())), 
    StandardCharsets.UTF_8
);

Ensure "yourTextFile.txt" is replaced with your actual file name. The snippet uses the URI of the file, and converts its bytes into a UTF-8 String.

Using Java NIO for Reading Files

Let's take a tour of Java NIO (Non-blocking I/O) and its optimized coins:

Paths.get: Crafts a Path from a URI, critical for resource fetching inside JAR files.
Files.readAllBytes: Reads all bytes asynchronously for better performance even with big-sized files contrasted to traditional I/O.
StandardCharsets.UTF_8: A distinct encoding like UTF-8 guards against data corruption during the transformation.

Check out the Alternatives

Even when the NIO's Files and Paths cater to our needs, it pays to have other options for file reading.

Involving Guava's Resources

If you're already working with Guava, it furnishes handy methods for this purpose:

String result = Resources.toString(
    Resources.getResource("yourTextFile.txt"), Charsets.UTF_8
);

Note: This is so simple, it feels like cheating. But remember, Guava's not part of JDK.

Harness Java 7 Approach

For Java 7, Files.readAllBytes and Paths.get were deal-breakers:

File myFile = new File(getClass().getResource("yourTextFile.txt").toURI());
String content = new String(Files.readAllBytes(myFile.toPath()), StandardCharsets.UTF_8);

History lesson: Prior to Java 8, we rolled like this. Old school, but not obsolete.

Java 11 in Action

Java 11 grants us Files.readString, simplifying file reading to another level:

String content = Files.readString(Paths.get(getClass().getClassLoader().getResource("yourTextFile.txt").toURI()), StandardCharsets.UTF_8);

This is what progress looks like in action. Simplified, but equally effective.

Classic `Scanner`

Using a Scanner with useDelimiter("\\A") keeps traditional flavor alive. This method suits older Java versions:

Scanner scanner = new Scanner(getClass().getResourceAsStream("/yourTextFile.txt"), "UTF-8").useDelimiter("\\A");
String content = scanner.hasNext() ? scanner.next() : "";

Note: Think of the scanner as that nostalgic grandpa who tells interesting stories - maybe not as quickly, but no less fascinating.

Importance of Proper Encoding

Regardless of the chosen strategy, consider the encoding. Leave defaults behind and set UTF-8 yourself. Your future self would thank you for avoiding unexpected tricky issues.

Keep it Lean and Clean

If the JDK serves your interests, minimize dependencies:

Shrink your application size and dodge dependency conflicts.
Say no to library bloat. Java: Keep it simple, stupid.

There are exceptions though. Apache Commons IO, for example, can serve additional functionality and clearer syntax:

String text = IOUtils.toString(getClass().getResourceAsStream("/yourTextFile.txt"), StandardCharsets.UTF_8);

Note: If you go down this path, remember to include Apache Commons IO in your dependencies. It's an outsider.

Handle Exceptions Like a Pro

Robust coding is never complete without proper exception handling. Better safe, than sorry.

Here's a bulletproof pattern:

String content;
try {
    URL url = getClass().getClassLoader().getResource("yourTextFile.txt");
    if (url != null) {
        Path path = Paths.get(url.toURI());
        content = Files.readString(path, StandardCharsets.UTF_8);
    } else {
        throw new FileNotFoundException("Where's the file, Lebowski?");
    }
} catch (IOException | URISyntaxException e) {
    // Log it, throw it, just don't ignore it.
}