Generate Random Integers in a Range in Java

By the end of this page, you will understand how to generate random integers in Java safely and correctly for both inclusive and exclusive ranges. You will also learn why some common formulas fail, how Random.nextInt(bound) works, and when to use Random, ThreadLocalRandom, or Math.random().

Generating a random integer in a range means producing a whole number between two limits, such as from 5 to 10.

The key idea is:

1. Find the size of the range
2. Generate a random offset inside that range
3. Shift that offset by the minimum value

For example, if the range is 5 to 10 inclusive, the possible values are:

• 5
• 6
• 7
• 8
• 9
• 10

That is 6 values total, so the range size is:

maximum - minimum + 1

Then you generate a random number from 0 up to rangeSize - 1, and add minimum.

In Java, the safest standard approach is usually:

Think of a random number in a range like picking a seat number in a row.

If seats go from 20 to 25, you do not directly guess a number from the whole world of integers. Instead:

1. Count how many seats exist
2. Pick a random position starting from 0
3. Move that many seats forward from seat 20

So:

• seat range: 20 to 25
• total seats: 6
• random offset: 0 to 5
• final seat: 20 + offset

That is exactly how random integer range formulas work.

The mistake beginners often make is mixing up:

• the largest allowed value
• the size of the range

These are not the same thing.

Basic inclusive range with Random

import java.util.Random;

Random random = new Random();
int minimum = 5;
int maximum = 10;

int randomNum = minimum + random.nextInt(maximum - minimum + 1);
System.out.println(randomNum);

This returns a value from 5 to 10, including both ends.

Why this works

random.nextInt(maximum - minimum + 1)

If minimum = 5 and maximum = 10, then:

maximum - minimum + 1 = 6

So nextInt(6) returns one of:

Consider this code:

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        int minimum = 3;
        int maximum = 7;

        int result = minimum + random.nextInt(maximum - minimum + 1);
        System.out.println(result);
    }
}

Step 1: Calculate the range size

maximum - minimum + 1

Substitute values:

7 - 3 + 1 = 5

So we need a random number from a set of 5 possible offsets.

Step 2: Generate the offset

Picking a random item ID for testing

When generating sample user IDs, order numbers, or ticket numbers, you often need a random integer in a valid numeric range.

Game development

Games use random ranges for:

• dice rolls
• enemy damage
• loot drops
• random spawn coordinates

Example:

int damage = ThreadLocalRandom.current().nextInt(10, 21);

This produces damage from 10 to 20 inclusive.

Simulations

In simulations such as queues, traffic, or load testing, random integers help model variable behavior.

Picking a random array index

String[] names = {"Ana", "Ben", "Cara"};
int index = ThreadLocalRandom.current().nextInt(0, names.length);
System.out.println(names[index]);

This is one of the most common real uses of ranged random integers.

Temporary codes or tokens

For simple non-secure uses such as demo verification codes:

In real projects, developers usually wrap random range logic in a helper method instead of repeating formulas everywhere.

Helper method pattern

import java.util.concurrent.ThreadLocalRandom;

public static int randomInRange(int min, int max) {
    if (min > max) {
        throw new IllegalArgumentException("min must be <= max");
    }
    return ThreadLocalRandom.current().nextInt(min, max + 1);
}

This improves readability and reduces mistakes.

Guard clause for validation

A common pattern is checking inputs early:

if (min > max) {
    throw new IllegalArgumentException("Invalid range");
}

This prevents hidden bugs later.

Configuration-driven ranges

Applications often read limits from config files or environment variables:

int minRetries = 1;
   ;
   ThreadLocalRandom.current().nextInt(minRetries, maxRetries + );

1. Using maximum instead of range size

Broken code:

int randomNum = minimum + (int)(Math.random() * maximum);

Why it is wrong:

• maximum is the upper value, not the number of possible values
• this can create numbers above the allowed maximum

Correct version:

int randomNum = minimum + (int)(Math.random() * (maximum - minimum + 1));

2. Using % to limit random numbers

Broken code:

int i = random.nextInt() % n;

Why it is wrong:

• results can be negative
• distribution may be uneven

Correct version:

int i = random.nextInt(n);

// Inclusive range: [min, max]
int value = min + random.nextInt(max - min + 1);

// Inclusive range with ThreadLocalRandom
int value = ThreadLocalRandom.current().nextInt(min, max + 1);

// Exclusive upper bound: [min, max)
int value = ThreadLocalRandom.current().nextInt(min, max);

// Math.random() version for inclusive range
int value = min + (int)(Math.random() * (max - min + 1));

Rules to remember

• nextInt(bound) returns 0 to bound - 1
• To include max, use max - min + 1
• Do not use % to force a random value into a range
• Validate that min <= max
• Watch out for overflow when using max + 1
• Use SecureRandom for security-sensitive values

How do I generate a random integer between two numbers in Java?

Use:

int value = min + random.nextInt(max - min + 1);

This gives a value from min to max inclusive.

Why does random.nextInt() % n give wrong results?

Because random.nextInt() can be negative, and % n can also be negative. It can also produce uneven distribution.

Is Math.random() okay for generating random integers?

Yes, if used correctly with the proper range formula. But Random or ThreadLocalRandom is usually clearer.

What is the easiest modern Java way to generate a number in a range?

ThreadLocalRandom.current().nextInt(min, max + 1)

This is very readable for inclusive ranges.

Is the upper bound included in nextInt(bound)?

No. The upper bound is exclusive.

• Java Random class — The standard API for generating pseudorandom values.
• ThreadLocalRandom — A modern and convenient choice for ranged random numbers, especially in multi-threaded code.
• SecureRandom — Important when randomness must be secure rather than just convenient.
• Inclusive vs exclusive ranges — Essential for understanding off-by-one behavior.
• Integer overflow — Relevant because range formulas often add 1 or shift values.
• Modulo operator % — Commonly misused in random range generation.
• Off-by-one errors — A frequent bug when building numeric ranges.
• Array indexing — Random integer ranges are often used to choose valid indexes.