How do I generate random integers within a specific range in Java?

The most common method to generate random integers within a specific range is using Math.random() of the java.lang package.

Generating random integers is a common task in Java, especially when working on games, OTP generation, and security-related applications. Java provides multiple ways to do this task. In this blog, we will learn how to generate random integers within a specific range using various methods.

Table of Contents:

• Methods to Generate Random Integers in a Specific Range in Java
  • Using Math.random() method
  • Using Random Class and nextInt() method
  • Using java.util.Random.ints()
  • Using java.util.concurrent.ThreadLocalRandom
• Generating Random Integers in a Range With Some Exclusions in Java
  • Using Math.random()
  • Using java.util.Random.nextInt()
  • Using java.util.Random.ints()
  • Custom Approach Using Streams or Collections
• Generating Secure Random Integers in Java
• Generating Random Hexadecimal, Alphanumeric Strings
  • Generating Random Hexadecimal Strings
  • Generating Random Alphanumeric Strings
• Generating Random Floating-Point Numbers in a Specific Range
  • Using Math.random()
  • Using Random.nextDouble()
• Conclusion

Methods to Generate Random Integers in a Specific Range in Java

Let’s learn how we can generate random integers in a specific range with the help of the following methods:

1. Using Math.random() method

We can use the Math.random() method to generate random integers within a specific range. The Math.random() method returns a double value between 0.0 (inclusive) and 1.0 (exclusive). To generate a random integer within a specific range [min, max], we use the following formula:

Syntax:

int randomNum = min + (int)(Math.random() * ((max – min) + 1));

Where min and max are the lower and upper limits of the range, respectively.

Example:

Output:

2. Using Random Class and nextInt() method

The Random class provides more flexibility for generating random integers. You can use the nextInt(int bound) method to get a random number from 0 (inclusive) to bound (exclusive):

Syntax:

Random rand = new Random();
int randomNum = rand.nextInt(max – min + 1) + min;

Here, we create an instance of the Random class and use the nextInt() method to generate a random integer within the range [min, max].

Example:

Output:

3. Using java.util.Random.ints()

The ints() method introduced in Java 8 can generate a stream of random integers within a specific range. Below is the syntax of the above method:

Syntax:

int randomInt = random.ints(min, max + 1).findFirst().getAsInt();

Where,

•  random.ints(min, max + 1): This function generates an IntStream of random integers starting from min (inclusive) to max + 1 (exclusive). 
• .findFirst().getAsInt(): This returns the first integer from the stream, and gives a single random integer within the specified range.

Example:

Output:

4. Using java.util.concurrent.ThreadLocalRandom

The java.util.concurrent.ThreadLocalRandom class, introduced in Java 7, provides an efficient way to generate random integers in multithreaded environments. Below is the syntax of the above method:

Syntax:

int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

Below is the code to generate random integers within a specific range using ThreadLocalRandom class.

Example:

Output:

Generating Random Integers in a Range With Some Exclusions in Java

We can also generate random integers in a range with some exclusions. Java provides multiple methods to do this task, let’s learn all these methods in more detail:

1. Using Math.random()

We can use Math.random() method to exclude some values in a specific range. To do this task, we have to follow  the below algorithm,

Algorithm:

• Calculate the total number of valid values by subtracting the number of excluded values from the range’s size.
• Generate a random integer within that specific range.
• Modify the generated integer by excluding those specific values.

Example:

Output:

2. Using java.util.Random.nextInt()

To generate a random number within a range with exclusions, we have to follow the below algorithm:

Algorithm:

• Similar to the Math.random() approach, calculate the modified range.
• Generate a random integer within this range.
• Do the operations to exclude values.

Example:

Output:

3. Using java.util.Random.ints()

Algorithm:

• Create a list of all possible values within the range, excluding the specified values.
• Randomly select an element from this list.

Example:

Output:

4. Custom Approach Using Streams or Collections

A custom approach involves creating a list of valid integers (excluding the undesired ones) and then selecting a random element from this list.

Algorithm:

• Create a list of all valid integers within the specified range.
• Remove the excluded integers from this list.
• Randomly select an element from the remaining list.

Example:

Output:

Generating Secure Random Integers in Java

In Java, generating secure random integers is important for applications that require cryptographic security, such as password generation, token creation, and secure key generation. The java.security.SecureRandom class provides a cryptographically strong random number generator (RNG).

Syntax:

int randomInt = secureRandom.nextInt((max - min) + 1) + min;

Example:

Output:

Generating Random Hexadecimal, Alphanumeric Strings

We can also generate random hexadecimal numbers and alphanumeric strings to generate unique IDs, security tokens, and cryptographic keys. Java Provides us with multiple methods to generate hexadecimal, and alphanumeric strings.

1. Generating Random Hexadecimal Strings

A hexadecimal string consists of characters from 0-9 and A-F. You can generate a random hexadecimal string using SecureRandom and BigInteger.

Example: Generate a Random Hexadecimal String

Output:

Explanation:

• SecureRandom generates cryptographically strong random bytes.
• BigInteger(1, bytes).toString(16) converts bytes to a hexadecimal string.
• In this way, we can generate random hexadecimal string

2. Generating Random Alphanumeric Strings

An alphanumeric string contains both letters (A-Z, a-z) and numbers (0-9). You can use Random or SecureRandom to generate these strings.

Example: Generate a Random Alphanumeric String

Output:

Explanation:

• Here, CHARACTERS contains all possible alphanumeric values.
• We can randomly select characters from this string using nextInt().

Generating Random Floating-Point Numbers in a Specific Range

A floating-point (decimal) number is often needed in probability calculations, and games. Java provides several ways to generate random floating-point numbers.

1. Using Math.random()

This is the simplest method to generate random floating-point numbers in a specific range:

Example: Generate a Random Floating-Point Number in a Given Range

Output:

Explanation: With the help of Math.random, we have generated a random integer between the min and max values.

2. Using Random.nextDouble()

You can also use the nextDouble() method of Random class to generate floating-point numbers. 

Example: Generate a Random Double Using Random class

Output:

Explanation:

• random.nextDouble() returns a value between 0.0 and 1.0.
• So with the help of this method, we can generate the random float integers within a range of (max, min).

Conclusion

So far in this article, we have learned how we can generate random integers within a specific range in more detail. We have explored various methods to do this operation like: Math.random() method, nextInt() method, Random.ints(), and ThreadLocalRand class. If you want to be a Java expert, you may refer to our Java course.

FAQs

int min = 1;
int max = 10;
int randomNumber = (int)(Math.random() * (max - min + 1)) + min;
System.out.println("Random number between " + min + " and " + max + ": " + randomNumber);