How to generate random integers within a specific range in Java?

In Java, you can generate random integers within a specific range using several approaches. Here are the most common methods, including modern and legacy options:

1. Using java.util.Random

This class provides a simple way to generate random integers within a range.

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        int min = 5;
        int max = 10;
        Random random = new Random();

        // Generates a random integer between 5 (inclusive) and 10 (inclusive)
        int randomNum = random.nextInt((max - min) + 1) + min;

        System.out.println(randomNum); // Example output: 7
    }
}

Explanation:

• random.nextInt((max - min) + 1) generates a value between 0 and (max - min).
• Adding min shifts the result to the desired range [min, max].

2. Using Math.random() (Legacy Approach)

The Math.random() method returns a double between 0.0 (inclusive) and 1.0 (exclusive). Convert it to an integer range:

int min = 5;
int max = 10;
int randomNum = (int) (Math.random() * (max - min + 1)) + min;
System.out.println(randomNum); // Example output: 9

3. Using ThreadLocalRandom (Java 8+)

For concurrent applications or better performance in multithreaded code:

import java.util.concurrent.ThreadLocalRandom;

int min = 5;
int max = 10;
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);
System.out.println(randomNum); // Example output: 5

Note:

• nextInt(int origin, int bound) generates values between origin (inclusive) and bound (exclusive).
• Use max + 1 to include the upper bound.

4. Using SecureRandom (Cryptographically Secure)

For security-sensitive applications (e.g., tokens, encryption):

import java.security.SecureRandom;

int min = 5;
int max = 10;
SecureRandom secureRandom = new SecureRandom();
int randomNum = secureRandom.nextInt((max - min) + 1) + min;

Key Considerations

Method	Pros	Cons
java.util.Random	Simple, widely used	Not thread-safe
Math.random()	No import needed	Limited flexibility, returns double
ThreadLocalRandom	Thread-safe, efficient (Java 8+)	Requires Java 8+
SecureRandom	Cryptographically secure	Slower than Random

Edge Cases

• Ensure min <= max (otherwise, methods throw IllegalArgumentException).
• All methods above are inclusive of both min and max.

Example Output Range

For min = 5 and max = 10, possible outputs include: 5, 6, 7, 8, 9, 10.

Choose the method based on your needs (simplicity, thread safety, or security). For most cases, ThreadLocalRandom (Java 8+) is recommended.