How to Generate a Random Number in a Range in Java

Q: Is the upper bound of nextInt inclusive or exclusive in Java?

Exclusive. nextInt(origin, bound) returns a value from origin up to bound - 1, and nextInt(n) returns 0 to n - 1. So nextInt(1, 6) never returns 6; for an inclusive range from min to max, call nextInt(min, max + 1) or min + rand.nextInt(max - min + 1). The same rule applies to nextDouble, ints, longs and doubles.

Q: How do I get the same random numbers every time?

Use a seeded Random: new Random(42) produces the same sequence on every run, because the algorithm of java.util.Random is part of its specification. ThreadLocalRandom cannot be seeded, and calling ThreadLocalRandom.current().setSeed(42) throws java.lang.UnsupportedOperationException. Keep the same method calls when you rely on a seeded sequence: with new Random(42), eight calls to nextInt(0, 8) give 5 7 1 0 4 3 3 5 but eight calls to nextInt(8) give 5 0 5 0 2 7 2 5.

Q: Why not use Math.abs(rand.nextInt()) % n?

Because it can return a negative number. Math.abs(Integer.MIN_VALUE) is -2147483648, since the positive value does not fit in an int, so one input in about four billion slips through. The modulo also favours small results slightly whenever n does not divide 2^32 evenly. rand.nextInt(n) and nextInt(origin, bound) avoid both problems.

Q: Can I use UUID.randomUUID() as a random string?

Yes, when the format does not matter. UUID.randomUUID().toString() is 36 characters, 32 hex digits plus four hyphens, and it is generated with a cryptographically strong generator. It carries 122 random bits, because six bits are fixed version and variant markers. For a specific length or alphabet, pick characters with SecureRandom, or Base64-encode random bytes.

Q: What is the difference between Random, ThreadLocalRandom and SecureRandom?

Random is seedable and thread-safe, but threads sharing one instance compete for it. ThreadLocalRandom gives each thread its own generator, so it is the fastest choice for general use, but it cannot be seeded. SecureRandom is slower and unpredictable, which is what you want for passwords, tokens and keys. All three implement the Java 17+ RandomGenerator interface, so they share methods such as nextInt(origin, bound) and ints(count, origin, bound).

Quick answer

Use ThreadLocalRandom.current().nextInt(min, max + 1). The second argument is exclusive, so the + 1 is what lets max itself come up: nextInt(1, 7) rolls a die from 1 to 6. For numbers that repeat on every run, use a seeded new Random(42), and for passwords or tokens use SecureRandom.

Every random API in Java draws from a half-open range: the lower end is included and the upper end is not. That one rule is behind most of the bugs in this area, from dice that never roll a 6 to the classic min + rand.nextInt(max - min + 1) formula that every older answer quotes. Since Java 17 the generators share the RandomGenerator interface, so Random, ThreadLocalRandom and SecureRandom all accept the same nextInt(origin, bound) call. Random output changes on every run, so the examples below either use a fixed seed or print checks such as allInRange: true instead of the numbers. Each one runs on this page: hit Run, then edit the code and run it again.

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

ThreadLocalRandom (Java 7+) is the generator to reach for in ordinary code. There is nothing to create or store: current() hands back the calling thread's own instance, so it is fast and never contended between threads. Its nextInt(origin, bound) returns a number from origin up to, but not including, bound. For an inclusive range, pass max + 1.

Main.java

import java.util.concurrent.ThreadLocalRandom;

public class Main {
    public static void main(String[] args) {
        int min = 1;
        int max = 6;

        // nextInt(origin, bound): the origin is included, the bound is not
        int roll = ThreadLocalRandom.current().nextInt(min, max + 1);
        System.out.println("roll is between 1 and 6: " + (roll >= min && roll <= max));

        // 10,000 draws: which values actually come up?
        int lowest = Integer.MAX_VALUE;
        int highest = Integer.MIN_VALUE;
        boolean allInRange = true;
        for (int i = 0; i < 10_000; i++) {
            int n = ThreadLocalRandom.current().nextInt(min, max + 1);
            lowest = Math.min(lowest, n);
            highest = Math.max(highest, n);
            allInRange &= n >= min && n <= max;
        }
        System.out.println("allInRange: " + allInRange);
        System.out.println("min seen: " + lowest + ", max seen: " + highest);

        // Forget the + 1 and max never comes up
        int highestWithoutPlusOne = Integer.MIN_VALUE;
        for (int i = 0; i < 10_000; i++) {
            highestWithoutPlusOne = Math.max(highestWithoutPlusOne,
                    ThreadLocalRandom.current().nextInt(min, max));
        }
        System.out.println("without + 1, max seen: " + highestWithoutPlusOne);

        // Negative ranges work the same way
        int temperature = ThreadLocalRandom.current().nextInt(-10, 11);
        System.out.println("-10..10: " + (temperature >= -10 && temperature <= 10));

        // The bound must be greater than the origin
        try {
            ThreadLocalRandom.current().nextInt(5, 5);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        }
    }
}

Output

Prints roll is between 1 and 6: true, allInRange: true and min seen: 1, max seen: 6: over 10,000 draws every face shows up. Drop the + 1 and the result is without + 1, max seen: 5. That is the off-by-one behind the Stack Overflow question, and it fails silently. Ranges that cross zero work the same way (-10..10: true), and an empty range throws IllegalArgumentException: bound must be greater than origin instead of returning something. Call ThreadLocalRandom.current() each time rather than keeping the result in a field that other threads might use.

2Random, seeds and min + nextInt(max - min + 1)

java.util.Random is the original generator, and the one to use when you need the same numbers every run: give it a seed and the sequence is fixed, which is what tests, simulations and procedurally generated levels want. Since Java 17 it has nextInt(origin, bound) too. On Java 8 to 16 you only have nextInt(n), which returns 0 to n - 1, so you shift it by min. That is the classic min + rand.nextInt(max - min + 1).

Main.java

import java.util.Random;
import java.util.random.RandomGenerator;

public class Main {
    public static void main(String[] args) {
        int min = 10;
        int max = 20;

        // A fixed seed gives the same sequence on every run
        Random random = new Random(42);

        // Java 17+: nextInt(origin, bound) on Random and every RandomGenerator
        for (int i = 0; i < 8; i++) {
            System.out.print(random.nextInt(min, max + 1) + " ");
        }
        System.out.println();

        // Before Java 17: nextInt(n) returns 0 to n - 1, so shift it by min
        Random classic = new Random(42);
        for (int i = 0; i < 8; i++) {
            System.out.print(min + classic.nextInt(max - min + 1) + " ");
        }
        System.out.println();

        // The off-by-one: nextInt(max - min) stops one short of max
        Random wrong = new Random(42);
        int highest = Integer.MIN_VALUE;
        for (int i = 0; i < 10_000; i++) {
            highest = Math.max(highest, min + wrong.nextInt(max - min));
        }
        System.out.println("nextInt(max - min), max seen: " + highest);

        // Java 17+: pick an algorithm by name through the RandomGenerator interface
        RandomGenerator lxm = RandomGenerator.of("L64X128MixRandom");
        int n = lxm.nextInt(min, max + 1);
        System.out.println("L64X128MixRandom in range: " + (n >= min && n <= max));
    }
}

Output

Both loops print 17 14 18 15 13 18 11 12, on this run and every other, because the seed is fixed. The shifted version without the + 1 tops out at nextInt(max - min), max seen: 19, one short of 20. The last line shows the Java 17+ RandomGenerator interface picking a newer LXM algorithm by name (L64X128MixRandom in range: true); code that takes a RandomGenerator parameter works with any of them. Create one Random and reuse it rather than calling new Random() for every number.

3Math.random() and doubles in a range

Math.random() returns a double from 0.0 (inclusive) to 1.0 (exclusive). To turn it into an int from min to max, multiply by the number of values, cast, then add min: (int) (Math.random() * (max - min + 1)) + min. It works, but the parentheses are easy to get wrong. For doubles in a range, Java 17+ has nextDouble(origin, bound); before that, scale nextDouble() yourself.

Main.java

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class Main {
    public static void main(String[] args) {
        int min = 1;
        int max = 6;

        // Math.random() returns a double from 0.0 (inclusive) to 1.0 (exclusive)
        int lowest = Integer.MAX_VALUE;
        int highest = Integer.MIN_VALUE;
        for (int i = 0; i < 10_000; i++) {
            int n = (int) (Math.random() * (max - min + 1)) + min;
            lowest = Math.min(lowest, n);
            highest = Math.max(highest, n);
        }
        System.out.println("Math.random() scaled, min seen: " + lowest + ", max seen: " + highest);

        // Misplaced parentheses: the cast runs first and truncates to 0
        int broken = (int) Math.random() * (max - min + 1) + min;
        System.out.println("(int) Math.random() * 6 + 1 = " + broken);

        // Doubles: nextDouble(origin, bound) is Java 17+; the bound is exclusive
        Random random = new Random(42);
        for (int i = 0; i < 3; i++) {
            double price = random.nextDouble(5.0, 10.0);
            System.out.println(price + " -> " + String.format("%.2f", price));
        }

        // Before Java 17: scale nextDouble() yourself
        double scaled = 5.0 + (10.0 - 5.0) * new Random(42).nextDouble();
        System.out.println("scaled by hand: " + scaled);

        // Unseeded doubles, checked instead of printed
        boolean allInRange = true;
        for (int i = 0; i < 10_000; i++) {
            double d = ThreadLocalRandom.current().nextDouble(-1.0, 1.0);
            allInRange &= d >= -1.0 && d < 1.0;
        }
        System.out.println("allInRange: " + allInRange);
    }
}

Output

The scaled version prints Math.random() scaled, min seen: 1, max seen: 6. Move the parentheses and you get (int) Math.random() * 6 + 1 = 1 on every run: the cast applies to Math.random() alone, truncating it to 0 before the multiply. The seeded doubles are 8.63781840016434 -> 8.64, 8.416117358799227 -> 8.42 and 6.543597276663299 -> 6.54, and the hand-scaled version gives the same first value, scaled by hand: 8.63781840016434. String.format only rounds for display; see round to 2 decimal places for rounding the value itself.

4Streams of random numbers: ints(count, min, max)

When you need many numbers at once, every generator has ints(count, origin, bound), which returns an IntStream with the same exclusive bound. There are longs and doubles versions too. Leave out the count and the stream is endless, which is handy with distinct() and limit() for picking numbers without repeats.

Main.java

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // ints(count, origin, bound): count numbers, bound exclusive
        int[] rolls = new Random(42).ints(10, 1, 7).toArray();
        System.out.println(Arrays.toString(rolls));

        // Boxed into a List (Stream.toList() is Java 16+)
        List<Integer> scores = new Random(42).ints(5, 0, 101).boxed().toList();
        System.out.println(scores);

        // Six different numbers from 1 to 49: an endless stream, deduplicated
        List<Integer> lottery = new Random(42).ints(1, 50)
                .distinct()
                .limit(6)
                .sorted()
                .boxed()
                .toList();
        System.out.println(lottery);

        // Roll 60,000 dice and count each face (TreeMap keeps keys sorted)
        Map<Integer, Long> faces = new Random(42).ints(60_000, 1, 7)
                .boxed()
                .collect(Collectors.groupingBy(n -> n, TreeMap::new, Collectors.counting()));
        System.out.println(faces);

        // The same call on ThreadLocalRandom, checked instead of printed
        boolean allInRange = ThreadLocalRandom.current().ints(10_000, 1, 7)
                .allMatch(n -> n >= 1 && n <= 6);
        System.out.println("allInRange: " + allInRange);
    }
}

Output

Ten seeded rolls print [3, 4, 1, 3, 1, 2, 6, 3, 2, 6] (print an array covers Arrays.toString), five scores print [15, 59, 4, 89, 11], and the six lottery numbers are [20, 26, 30, 32, 34, 35]. The dice counts, {1=9932, 2=9943, 3=10147, 4=9907, 5=9970, 6=10101}, are all close to 10,000, so the range is uniform. distinct() on an endless stream keeps drawing until it has six different values; if you want most of a small range, shuffling a list is more direct (see the FAQ).

5SecureRandom: tokens and a random alphanumeric string

Random and ThreadLocalRandom are predictable: someone who sees a few outputs can work out the rest. For passwords, reset links, session IDs and one-time codes use java.security.SecureRandom. It extends Random, so it has the same nextInt(origin, bound). A random alphanumeric string is just a loop that picks random characters from an alphabet. Writing it against RandomGenerator lets the same method take a seeded Random in tests and a SecureRandom in production. Apache Commons Lang has RandomStringUtils for this, but you don't need a library.

Main.java

import java.security.SecureRandom;
import java.util.Base64;
import java.util.HexFormat;
import java.util.Random;
import java.util.random.RandomGenerator;

public class Main {
    static final String ALPHANUMERIC =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    // Works with any generator: Random, SecureRandom, ThreadLocalRandom
    static String randomString(RandomGenerator rng, int length) {
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append(ALPHANUMERIC.charAt(rng.nextInt(ALPHANUMERIC.length())));
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        // Seeded Random: repeatable, fine for test data, never for secrets
        System.out.println(randomString(new Random(42), 12));
        System.out.println(randomString(new Random(42), 12));

        // SecureRandom for anything someone must not be able to guess
        SecureRandom secure = new SecureRandom();
        String code = randomString(secure, 12);
        System.out.println("code: " + code.length() + " chars, alphanumeric: "
                + code.matches("[A-Za-z0-9]{12}"));

        // Tokens: random bytes, then encode them
        byte[] bytes = new byte[32];
        secure.nextBytes(bytes);
        String token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
        System.out.println("base64url token: " + token.length() + " chars, url-safe: "
                + token.matches("[A-Za-z0-9_-]+"));
        String hex = HexFormat.of().formatHex(bytes); // Java 17+
        System.out.println("hex token: " + hex.length() + " chars");

        // A 6-digit one-time code, zero-padded
        String otp = String.format("%06d", secure.nextInt(0, 1_000_000));
        System.out.println("otp: " + otp.length() + " digits, numeric: " + otp.matches("\\d{6}"));
    }
}

Output

The seeded string is Gpi2C7DgXDiA both times, which is exactly why a seeded Random must never make secrets. The SecureRandom lines change every run, so they print checks: code: 12 chars, alphanumeric: true, base64url token: 43 chars, url-safe: true, hex token: 64 chars and otp: 6 digits, numeric: true. For tokens, encoding random bytes is simpler than picking characters: 32 bytes is 256 bits of randomness, 43 characters in URL-safe Base64 or 64 in hex (HexFormat is Java 17+). Create one SecureRandom and reuse it.

6Which should you use?

Method	Range	Repeatable	Best for
ThreadLocalRandom.current().nextInt(min, max + 1)	min to max	No (cannot be seeded)	Everyday random numbers, any thread
new Random(seed).nextInt(min, max + 1)	min to max (Java 17+)	Yes, with a seed	Tests, simulations, games
min + rand.nextInt(max - min + 1)	min to max	Yes, with a seed	Java 8 to 16
(int) (Math.random() * (max - min + 1)) + min	min to max	No	Old code; easy to get the parentheses wrong
rng.ints(count, min, max + 1)	min to max	With a seeded Random	Many numbers at once, stream pipelines
new SecureRandom().nextInt(min, max + 1)	min to max	No (by design)	Passwords, tokens, one-time codes

Frequently asked questions

Is the upper bound of nextInt inclusive or exclusive in Java?

Exclusive. nextInt(origin, bound) returns a value from origin up to bound - 1, and nextInt(n) returns 0 to n - 1. So nextInt(1, 6) never returns 6; for an inclusive range from min to max, call nextInt(min, max + 1) or min + rand.nextInt(max - min + 1). The same rule applies to nextDouble, ints, longs and doubles.

How do I get the same random numbers every time?

Use a seeded Random: new Random(42) produces the same sequence on every run, because the algorithm of java.util.Random is part of its specification. ThreadLocalRandom cannot be seeded, and calling ThreadLocalRandom.current().setSeed(42) throws java.lang.UnsupportedOperationException. Keep the same method calls when you rely on a seeded sequence: with new Random(42), eight calls to nextInt(0, 8) give 5 7 1 0 4 3 3 5 but eight calls to nextInt(8) give 5 0 5 0 2 7 2 5.

Why not use Math.abs(rand.nextInt()) % n?

Because it can return a negative number. Math.abs(Integer.MIN_VALUE) is -2147483648, since the positive value does not fit in an int, so one input in about four billion slips through. The modulo also favours small results slightly whenever n does not divide 2^32 evenly. rand.nextInt(n) and nextInt(origin, bound) avoid both problems.

How do I generate random numbers without duplicates?

To pick a few values from a large range, take a stream and drop repeats: rng.ints(1, 50).distinct().limit(6). To use most or all of a small range, shuffle a list instead: shuffling the numbers 1 to 10 with Collections.shuffle(list, new Random(42)) gives [5, 7, 3, 2, 8, 10, 9, 6, 4, 1]. Leave out the Random argument for a different order each run.

Can I use UUID.randomUUID() as a random string?

Yes, when the format does not matter. UUID.randomUUID().toString() is 36 characters, 32 hex digits plus four hyphens, and it is generated with a cryptographically strong generator. It carries 122 random bits, because six bits are fixed version and variant markers. For a specific length or alphabet, pick characters with SecureRandom, or Base64-encode random bytes.

What is the difference between Random, ThreadLocalRandom and SecureRandom?

Random is seedable and thread-safe, but threads sharing one instance compete for it. ThreadLocalRandom gives each thread its own generator, so it is the fastest choice for general use, but it cannot be seeded. SecureRandom is slower and unpredictable, which is what you want for passwords, tokens and keys. All three implement the Java 17+ RandomGenerator interface, so they share methods such as nextInt(origin, bound) and ints(count, origin, bound).

Run it yourself

Open any of these in the full Java editor to tweak, run and share.

Java playground