Cookbooks
Java
Chapter 3. Numbers
Generating random numbers

Java:
Generating random numbers

How to:

In Java, generating random numbers can be achieved using the Random class from the java.util package, or the ThreadLocalRandom and SecureRandom classes for specific use cases. The following examples illustrate how to use these classes.

Using the Random class

The Random class offers a way to generate simple pseudo-random numbers.

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        Random rand = new Random(); // Create a Random object

        int randInt = rand.nextInt(50); // Generates a random integer from 0 to 49
        double randDouble = rand.nextDouble(); // Generates a random double between 0.0 and 1.0
        boolean randBoolean = rand.nextBoolean(); // Generates a random boolean
        
        System.out.println("Random Int: " + randInt);
        System.out.println("Random Double: " + randDouble);
        System.out.println("Random Boolean: " + randBoolean);
    }
}

Using ThreadLocalRandom class

For concurrent applications, ThreadLocalRandom is more efficient than Random.

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomExample {
    public static void main(String[] args) {
        int randInt = ThreadLocalRandom.current().nextInt(1, 101); // From 1 to 100
        double randDouble = ThreadLocalRandom.current().nextDouble(1.0, 10.0); // From 1.0 to 10.0
        
        System.out.println("Random Int: " + randInt);
        System.out.println("Random Double: " + randDouble);
    }
}

Using SecureRandom class

For cryptographic operations, SecureRandom provides a higher level of security.

import java.security.SecureRandom;

public class SecureRandomExample {
    public static void main(String[] args) {
        SecureRandom secRand = new SecureRandom();
        
        byte[] bytes = new byte[20];
        secRand.nextBytes(bytes); // Fills bytes with secure random numbers
        
        System.out.println("Secure Random Bytes:");
        for (byte b : bytes) {
            System.out.printf("%02x ", b);
        }
    }
}

Deep Dive

Random number generation has evolved significantly since the early days of computing. Java’s Random class uses a linear congruential formula to generate pseudo-random numbers, which are deterministic and not suitable for high-security applications. This led to the introduction of SecureRandom, which uses more sophisticated algorithms (e.g., SHA1PRNG) to produce cryptographically strong random numbers.

However, Random and SecureRandom have their shortcomings, such as performance degradation in multithreaded environments. The ThreadLocalRandom class was introduced in Java 7 to address this issue by providing thread-local random number generators, significantly improving performance in concurrent applications.

While these classes cover most needs, for extremely high-scale or specialized requirements, developers might explore additional libraries or develop custom solutions. It’s essential to choose the right approach based on the use case’s security needs and performance requirements.

Rounding numbers