## How do I generate random integers within a specific range in Java?

### Question

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`.
``````
2019/01/05
1
3562
1/5/2019 10:13:34 AM

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))
``````
2019/02/08

Use:

``````Random ran = new Random();
int x = ran.nextInt(6) + 5;
``````

The integer `x` is now the random number that has a possible outcome of `5-10`.

2019/02/08

Use:

``````minimum + rn.nextInt(maxValue - minvalue + 1)
``````
2014/06/22

With they introduced the method `ints(int randomNumberOrigin, int randomNumberBound)` in the `Random` class.

For example if you want to generate five random integers (or a single one) in the range [0, 10], just do:

``````Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
``````

The first parameter indicates just the size of the `IntStream` generated (which is the overloaded method of the one that produces an unlimited `IntStream`).

If you need to do multiple separate calls, you can create an infinite primitive iterator from the stream:

``````public final class IntRandomNumberGenerator {

private PrimitiveIterator.OfInt randomIterator;

/**
* Initialize a new random number generator that generates
* random numbers in the range [min, max]
* @param min - the min value (inclusive)
* @param max - the max value (inclusive)
*/
public IntRandomNumberGenerator(int min, int max) {
randomIterator = new Random().ints(min, max + 1).iterator();
}

/**
* Returns a random number in the range (min, max)
* @return a random number in the range (min, max)
*/
public int nextInt() {
return randomIterator.nextInt();
}
}
``````

You can also do it for `double` and `long` values. I hope it helps! :)

2020/04/02

You can edit your second code example to:

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