How to Generate a Random Byte Array of N Bytes

1. Overview

There are multiple ways to generate random byte arrays, each suited to different needs. In this tutorial, we’ll explore three approaches: using the built-in java.util.Random class, the cryptographically secure java.security.SecureRandom, and Apache Commons utilities, including RandomUtils and UniformRandomProvider.

By the end of this tutorial, we’ll have a comprehensive understanding of how to generate random byte arrays of any size, and when to choose each method.

2. Using Random

The java.util.Random class provides a straightforward way to generate random byte arrays. It’s ideal for scenarios where performance is more critical than security, such as generating non-sensitive random data for testing:

@Test
public void givenSizeWhenGenerateUsingRandomThenOK() {
    byte[] byteArray = new byte[SIZE];
    Random random = new Random();
    random.nextBytes(byteArray);

    assertEquals(SIZE, byteArray.length);
}

Since Random isn’t cryptographically secure, we shouldn’t use it for security-sensitive data.

3. Using SecureRandom

When generating random data that must be secure and unpredictable, SecureRandom is the preferred choice. It’s specifically designed to produce cryptographically strong random values:

@Test
public void givenSizeWhenGenerateUsingSecureRandomThenOK() {
    byte[] byteArray = new byte[SIZE];
    SecureRandom secureRandom = new SecureRandom();
    secureRandom.nextBytes(byteArray);

    assertEquals(SIZE, byteArray.length);
}

SecureRandom is slower but necessary for generating secure random data.

4. Using Apache Commons

Apache Commons Lang provides the RandomUtils class, which offers additional methods for generating random data. To use Apache Commons Lang, we add the commons-lang3 dependency in our pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.16.0</version>
</dependency>

This utility class simplifies the process and integrates seamlessly with other Commons Lang features.

Let’s see it in action:

@Test
public void givenSizeWhenGenerateUsingRandomUtilsThenOK() {
    byte[] byteArray = RandomUtils.nextBytes(SIZE);

    assertEquals(SIZE, byteArray.length);
}

However, it’s important to note that RandomUtils is now deprecated, and it’s recommended to use Apache Commons RNG instead. Apache Commons RNG provides a more robust and efficient way to generate random data. To use it, let’s include the commons-rng-simple dependency:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-rng-simple</artifactId>
    <version>1.6</version>
</dependency>

Let’s generate a random byte array using UniformRandomProvider from Apache Commons RNG:

@Test
public void givenSizeWhenGenerateUsingUniformRandomProviderThenOK() {
    byte[] byteArray = new byte[SIZE];
    UniformRandomProvider randomProvider = RandomSource.XO_RO_SHI_RO_128_PP.create();
    randomProvider.nextBytes(byteArray);

    assertEquals(SIZE, byteArray.length);
}

UniformRandomProvider not only offers a more reliable and up-to-date API for generating random data, but it also outperforms the other methods discussed, including Random, making it the fastest option.

UniformRandomProvider outperforms other methods because it’s built on modern algorithms like XO_RO_SHI_RO_128_PP, which is a variant of the XOR shift algorithm. This algorithm offers a better balance of speed, statistical quality, and memory efficiency compared to older implementations like Random.

The XO_RO_SHI_RO family of algorithms delivers speed and ensures a long period, which is crucial for high-performance applications.

Additionally, Apache Commons RNG offers a variety of other algorithms to suit different needs, such as MT (Mersenne Twister) and SPLIT_MIX_64.

5. Conclusion

In this article, we explored three different ways to generate random byte arrays: using java.util.Random, java.security.SecureRandom, and Apache Commons. Each method has its strengths and is suited to different scenarios. By understanding these options, we can choose the most appropriate approach for our specific requirements, whether we need performance, security, or convenience.