# Generating random integers in a range with Java

I am trying to generate a random integer with Java, but random in a specific range. For example, my range is 5-10, meaning that 5 is the smallest possible value the random number can take, and 10 is the biggest. Any other number in between these numbers is possible to be a value, too.

In Java, there is a method `random()`

in the `Math`

class, which returns a `double`

value between 0.0 and 1.0. In the class `Random`

there is a method `nextInt(int n)`

, which returns a random integer value in the range of 0 (inclusive) and n (exclusive). I couldn't find a method, which returns a random integer value between two numbers.

I have tried the following things, but I still have problems: (minimum and maximum are the smallest and biggest numbers).

Solution 1:

`randomNum = minimum + (int)(Math.random()*maximum); `

Problem: `randomNum`

is assinged values numbers bigger than `maximum`

.

Solution 2:

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

Problem: `randomNum`

is assigned values smaller than `minimum`

.

How do I solve this problem?

I have tried also browsing through the archive and found:

- Expand a random range from 1–5 to 1–7
- Generate random numbers uniformly over an entire range

But I couldn't solve the problem.

### 1Answer

The standard way to do this (before Java 1.7) is as follows:

```
import java.util.Random;
/**
* Returns a pseudo-random number between min and max, inclusive.
* The difference between min and max can be at most
* <code>Integer.MAX_VALUE - 1</code>.
*
* @param min Minimum value
* @param max Maximum value. Must be greater than min.
* @return Integer between min and max, inclusive.
* @see java.util.Random#nextInt(int)
*/
public static int randInt(int min, int max) {
// NOTE: This will (intentionally) not run as written so that folks
// copy-pasting have to think about how to initialize their
// Random instance. Initialization of the Random instance is outside
// the main scope of the question, but some decent options are to have
// a field that is initialized once and then re-used as needed or to
// use ThreadLocalRandom (if using at least Java 1.7).
Random rand;
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = rand.nextInt((max - min) + 1) + min;
return randomNum;
}
```

See the relevant JavaDoc. In practice, the java.util.Random class is often preferable tojava.lang.Math.random().

In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.

In Java 1.7 or later, the following method is even more straightforward as long as there is no need to explicitly set the initial seed:

```
import java.util.concurrent.ThreadLocalRandom;
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
ThreadLocalRandom.current().nextInt(min, max + 1);
```

- answered 7 years ago
- G John

## Your Answer