Generate a Random Number in a Specific Range in Java and Android

By the end of this page, you will understand how to generate random integers inside a specific range in Java for Android, why nextInt() works the way it does, how to build the correct formula using a minimum and maximum value, and which common mistakes cause numbers to go outside the expected range.

In Java, Random.nextInt(bound) does not generate a number from 1 to bound. It generates a number from:

0 to bound - 1

So this code:

r.nextInt(80)

returns a value from 0 to 79.

If you then add 65:

r.nextInt(80) + 65

the final result becomes:

65 to 144

That is why your code can return values greater than 80.

To generate a random number between min and max inclusive, use this formula:

Think of nextInt(bound) as a machine that always starts counting from 0.

If you want numbers in a different range, you do two things:

1. Tell it how many numbers you need
2. Shift the result to where your range starts

For the range 65 to 80:

• The machine should produce 16 possible numbers
• Those numbers are initially 0 to 15
• Then you shift them by adding 65
• Final result becomes 65 to 80

So the process is:

0..15  -> add 65 -> 65..80

That is the key idea: generate from zero, then shift into place.

The standard Java syntax is:

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

Example: random number from 65 to 80

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        int value = random.nextInt(80 - 65 + 1) + 65;
        System.out.println(value);
    }
}

Possible output:

65
72
80
68

Example using variables

Consider this code:

Random random = new Random();
int min = 65;
int max = 80;
int value = random.nextInt(max - min + 1) + min;

Let’s trace it step by step.

Step 1: Calculate the range size

max - min + 1

becomes:

80 - 65 + 1 = 16

So now the code is effectively:

int value = random.nextInt(16) + 65;

Step 2: nextInt(16) generates a value from 0 to 15

Possible results:

Random numbers in a specific range are common in real apps.

Games

• rolling dice
• generating enemy damage values
• random spawn positions within limits

int damage = random.nextInt(10 - 5 + 1) + 5;

OTP or verification demo values

• generating a 4-digit or 6-digit demo code

int code = random.nextInt(9999 - 1000 + 1) + 1000;

Quiz or flashcard apps

• selecting a random question index
• picking random rewards

Test data generation

• random ages, scores, ratings, or IDs for development

int age = random.nextInt(60 - 18 + 1) + 18;

UI behavior

In real projects, developers often wrap random-range logic inside a helper method so they do not repeat the formula everywhere.

Helper method

import java.util.Random;

public class RandomUtils {
    private static final Random random = new Random();

    public static int randomInRange(int min, int max) {
        if (min > max) {
            throw new IllegalArgumentException("min cannot be greater than max");
        }
        return random.nextInt(max - min + 1) + min;
    }
}

Usage:

int value = RandomUtils.randomInRange(65, 80);

Guard clause for validation

A common pattern is to validate inputs early:

1. Using the max value directly in nextInt()

Broken code:

Random random = new Random();
int value = random.nextInt(80) + 65;

Problem:

• this produces 65 to 144
• 80 is treated as the count, not the final maximum

Fix:

int value = random.nextInt(80 - 65 + 1) + 65;

2. Forgetting the + 1

Broken code:

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

Problem:

vs

Generate random integer in an inclusive range

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

Example

Random random = new Random();
int value = random.nextInt(80 - 65 + 1) + 65;

What nextInt(bound) means

random.nextInt(5)

returns:

0, 1, 2, 3, 4

Rules

• nextInt(bound) starts at 0
• upper limit is excluded
• use max - min + 1 for inclusive ranges

How do I generate a random number between 65 and 80 in Java?

Use:

Random random = new Random();
int value = random.nextInt(80 - 65 + 1) + 65;

Why does random.nextInt(80) + 65 go above 80?

Because nextInt(80) returns 0 to 79. After adding 65, the result becomes 65 to 144.

Does nextInt(bound) include the bound value?

No. It includes 0 and excludes bound.

How do I include both minimum and maximum values?

Use:

random.nextInt(max - min + 1) + min

• Random class — The main Java utility for generating random values.
• Math.random() — Another way to generate random numbers in Java.
• Inclusive vs exclusive ranges — Important for understanding off-by-one errors.
• Variables — Useful for storing min, max, and the generated value.
• Methods — Helpful for wrapping range logic into reusable functions.
• Input validation — Prevents invalid ranges such as min > max.
• Off-by-one errors — A common bug when calculating range sizes.