How to Convert a byte[] to URI in Java 8 — Step-by-Step Guide

Working with byte[] data is common in Java applications — for example, when reading input streams, files, or network responses.
In many cases, you may need to convert this binary data into a URI (Uniform Resource Identifier) to access or reference a resource programmatically.

In this article, we’ll walk through the cleanest way to convert a byte[] to a URI in Java 8, and highlight a few common pitfalls to avoid.

Step 1: Understand What the byte[] Represents

Before converting, it’s important to know what your byte array actually contains.

If the byte[] represents a URI string encoded in UTF-8 (for example, http://example.com), then the process is straightforward.
If it represents binary data (like an image or PDF), you’ll need to store it somewhere and then create a URI to that file instead.

Step 2: Convert byte[] to String

Use the String constructor with a specific charset — preferably StandardCharsets.UTF_8 — to avoid platform-dependent issues.

import java.nio.charset.StandardCharsets;

byte[] uriBytes = "http://example.com".getBytes(StandardCharsets.UTF_8);
String uriString = new String(uriBytes, StandardCharsets.UTF_8);

This step ensures that your byte array is safely decoded into a readable URI string.

Step 3: Convert String to URI

Now that you have the URI string, simply pass it to the URI constructor:

import java.net.URI;

URI uri = new URI(uriString);
System.out.println("Converted URI: " + uri);

This will output:

Converted URI: http://example.com

Step 4: Handle Possible Exceptions

When working with user input or dynamic data, the URI string might not always be valid.
Always wrap your conversion in a try-catch block to handle URISyntaxException:

try {
    URI uri = new URI(uriString);
    System.out.println("Converted URI: " + uri);
} catch (Exception e) {
    e.printStackTrace();
}

Step 5: Example — From Database to URI

In real projects, you might retrieve a URI as bytes from a database ResultSet:

ResultSet resultSet = statement.executeQuery("SELECT bank_url FROM banks");
while (resultSet.next()) {
    byte[] urlBytes = resultSet.getBytes("bank_url");
    if (urlBytes != null) {
        String urlString = new String(urlBytes, StandardCharsets.UTF_8);
        URI uri = new URI(urlString);
        System.out.println("Bank URL: " + uri);
    }
}

This approach ensures that the conversion is both safe and readable, and it can easily be extended to logging or entity mapping layers.

Common Issues

1. NullPointerException
Occurs if the byte[] value is null. Always perform a null check before conversion.

2. URISyntaxException
Thrown when the String contains invalid URI characters. You can sanitize the string before conversion using URLEncoder if needed.

Conclusion

Converting a byte[] to a URI in Java 8 is simple once you understand the data encoding involved.
By explicitly using UTF-8, validating for null, and handling syntax exceptions, you ensure your code is portable and error-free across platforms.