# numbers number - How to generate random integers within a specific range in Java?

Note that this approach is more biased and less efficient than a `nextInt` approach, https://stackoverflow.com/a/738651/360211

One standard pattern for accomplishing this is:

``````Min + (int)(Math.random() * ((Max - Min) + 1))
``````

The Java Math library function Math.random() generates a double value in the range `[0,1)`. Notice this range does not include the 1.

In order to get a specific range of values first, you need to multiply by the magnitude of the range of values you want covered.

``````Math.random() * ( Max - Min )
``````

This returns a value in the range `[0,Max-Min)`, where 'Max-Min' is not included.

For example, if you want `[5,10)`, you need to cover five integer values so you use

``````Math.random() * 5
``````

This would return a value in the range `[0,5)`, where 5 is not included.

Now you need to shift this range up to the range that you are targeting. You do this by adding the Min value.

``````Min + (Math.random() * (Max - Min))
``````

You now will get a value in the range `[Min,Max)`. Following our example, that means `[5,10)`:

``````5 + (Math.random() * (10 - 5))
``````

But, this still doesn't include `Max` and you are getting a double value. In order to get the `Max` value included, you need to add 1 to your range parameter `(Max - Min)` and then truncate the decimal part by casting to an int. This is accomplished via:

``````Min + (int)(Math.random() * ((Max - Min) + 1))
``````

And there you have it. A random integer value in the range `[Min,Max]`, or per the example `[5,10]`:

``````5 + (int)(Math.random() * ((10 - 5) + 1))
``````
between digit 10

How do I generate a random `int` value in a specific range?

I have tried the following, but those do not work:

Attempt 1:

``````randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.
``````

Attempt 2:

``````Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.
``````

Use:

``````minimum + rn.nextInt(maxValue - minvalue + 1)
``````

You can edit your second code example to:

``````Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;
``````

ThreadLocalRandom equivalent of class java.util.Random for multithreaded environment. Generating a random number is carried out locally in each of the threads. So we have a better performance by reducing the conflicts.

``````int rand = ThreadLocalRandom.current().nextInt(x,y);
``````

x,y - intervals e.g. (1,10)

Forgive me for being fastidious, but the solution suggested by the majority, i.e., `min + rng.nextInt(max - min + 1))`, seems perilous due to the fact that:

• `rng.nextInt(n)` cannot reach `Integer.MAX_VALUE`.
• `(max - min)` may cause overflow when `min` is negative.

A foolproof solution would return correct results for any `min <= max` within [`Integer.MIN_VALUE`, `Integer.MAX_VALUE`]. Consider the following naive implementation:

``````int nextIntInRange(int min, int max, Random rng) {
if (min > max) {
throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
}
int diff = max - min;
if (diff >= 0 && diff != Integer.MAX_VALUE) {
return (min + rng.nextInt(diff + 1));
}
int i;
do {
i = rng.nextInt();
} while (i < min || i > max);
return i;
}
``````

Although inefficient, note that the probability of success in the `while` loop will always be 50% or higher.

Let us take an example.

Suppose I wish to generate a number between 5-10:

``````int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);
``````

Let us understand this...

Initialize max with highest value and min with the lowest value.

Now, we need to determine how many possible values can be obtained. For this example, it would be:

5, 6, 7, 8, 9, 10

So, count of this would be max - min + 1.

i.e. 10 - 5 + 1 = 6

The random number will generate a number between 0-5.

i.e. 0, 1, 2, 3, 4, 5

Adding the min value to the random number would produce:

5, 6, 7, 8, 9, 10

Hence we obtain the desired range.

Here's a helpful class to generate random `ints` in a range with any combination of inclusive/exclusive bounds:

``````import java.util.Random;

public class RandomRange extends Random {
public int nextIncInc(int min, int max) {
return nextInt(max - min + 1) + min;
}

public int nextExcInc(int min, int max) {
return nextInt(max - min) + 1 + min;
}

public int nextExcExc(int min, int max) {
return nextInt(max - min - 1) + 1 + min;
}

public int nextIncExc(int min, int max) {
return nextInt(max - min) + min;
}
}
``````

``````int random = minimum + Double.valueOf(Math.random()*(maximum-minimun)).intValue();
``````

Or take a look to RandomUtils from Apache Commons.

This methods might be convenient to use:

This method will return a random number between the provided min and max value:

``````public static int getRandomNumberBetween(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt(max - min) + min;
if (randomNumber == min) {
// Since the random number is between the min and max values, simply add 1
return min + 1;
} else {
return randomNumber;
}
}
``````

and this method will return a random number from the provided min and max value (so the generated number could also be the min or max number):

``````public static int getRandomNumberFrom(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt((max + 1) - min) + min;

return randomNumber;
}
``````

I found this example Generate random numbers :

This example generates random integers in a specific range.

``````import java.util.Random;

/** Generate random integers in a certain range. */
public final class RandomRange {

public static final void main(String... aArgs){
log("Generating random integers in the range 1..10.");

int START = 1;
int END = 10;
Random random = new Random();
for (int idx = 1; idx <= 10; ++idx){
showRandomInteger(START, END, random);
}

log("Done.");
}

private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
if ( aStart > aEnd ) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
//get the range, casting to long to avoid overflow problems
long range = (long)aEnd - (long)aStart + 1;
// compute a fraction of the range, 0 <= frac < range
long fraction = (long)(range * aRandom.nextDouble());
int randomNumber =  (int)(fraction + aStart);
log("Generated : " + randomNumber);
}

private static void log(String aMessage){
System.out.println(aMessage);
}
}
``````

An example run of this class :

``````Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.
``````

``````public static Random RANDOM = new Random(System.nanoTime());

public static final float random(final float pMin, final float pMax) {
return pMin + RANDOM.nextFloat() * (pMax - pMin);
}
``````

Here is a simple sample that shows how to generate random number from closed `[min, max]` range, while `min <= max is true`

You can reuse it as field in hole class, also having all `Random.class` methods in one place

Results example:

``````RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert
``````

Sources:

``````import junit.framework.Assert;
import java.util.Random;

public class RandomUtils extends Random {

/**
* @param min generated value. Can't be > then max
* @param max generated value
* @return values in closed range [min, max].
*/
public int nextInt(int min, int max) {
Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
if (min == max) {
return max;
}

return nextInt(max - min + 1) + min;
}
}
``````

Another option is just using Apache Commons:

``````import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;

public void method() {
RandomData randomData = new RandomDataImpl();
int number = randomData.nextInt(5, 10);
// ...
}
``````

``````private static Random random = new Random();

public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
``````

OR

``````public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + min;
}
``````

``````rand.nextInt((max+1) - min) + min;
``````

This is working fine.

### Tags

java   random   integer