How can I generate a random number in a specific range in Android?

Ranges and boundaries: the lay of the land

Random does a bit of magic when generating a number. Conjure a number, it's saying, but keep it within these walls. The walls, or "bounds", start at zero. So for nextInt(int bound), if your walls or "bounds" don't start at zero, adjust the formula to match:

// This kettle of code is brewing a hot, steamy random number just for you.
Random r = new Random();
int min = 5;
int max = 15;
int randomInclusive = r.nextInt(max - min + 1) + min; // Brew includes all ingredients, max is part of the mix.
int randomExclusive = r.nextInt(max - min) + min;     // Hmm, this brew doesn't taste like max. Oh, it's max-free.


The exclusive range leaves out the maximum value, while the inclusive range lets maximum join the party.

Behind the curtains: workings of the Random class

Get a glimpse into the backstage of the Random class, the 'butler' that serves you a random number from the 'reservoir' of possibilities.

Other spells at your disposal

Turn to different methods when plain old Random doesn't cut it, or the situation calls for higher-level spells:

ThreadLocalRandom (Best for multi-threaded sorcery)

int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1); // You've got it threaded.


SecureRandom (For when you need a charm against predictability)

SecureRandom secureRandom = new SecureRandom();
int randomNum = secureRandom.nextInt(max - min + 1) + min; // Secure and encrypted. No peeking.


Streams (Java 8's magic stream of randomness)

int randomNum = Random.ints(min, max + 1).findFirst().getAsInt(); // Streaming the river of randomness


Picking the right spell: Random vs SecureRandom vs ThreadLocalRandom

Not sure which method to use when a wild scenario appears? It's all about understanding your environment. SecureRandom is your ally in cryptographically secure applications, while ThreadLocalRandom saves the day in a multithreaded environment. When in doubt, 😉 Random is a good place to start, unless you need a set of special use-cases.

Watch your step: potential pitfalls to avoid

All magic has its risk, here's what to keep in mind:

• Max shyness: nextInt is a little shy of the max value. Don't forget the +1 in nextInt, without it maximum value won't show.
• Reversed ranges: Always champion max > min. Else, you'll face the IllegalArgumentException boss.
• Gigantic ranges: With large ranges, remember to think about performance trade-offs and the distribution of your pseudorandom numbers.