**I just announced the new *** Learn Spring * course, focused on the fundamentals of Spring 5 and Spring Boot 2:

*Learn Spring*course, focused on the fundamentals of Spring 5 and Spring Boot 2:

**>> CHECK OUT THE COURSE**

Last modified: March 28, 2020

In this tutorial, we'll explore different ways of generating random numbers within a range.

The *Math.random* gives a random *double* value which is greater than or equal to 0.0 and less than 1.0.

Let's use the *Math.random *method to generate a random number in a given range:

```
public int getRandomNumber(int min, int max) {
return (int) ((Math.random() * (max - min)) + min);
}
```

**Why does that work? Well, let's look at what happens when Math.random returns 0.0, it's the lowest possible output:**

`0.0 * (max - min) + min => min`

So, the lowest number we can get is *min.*

If *Math.random *returns 1.0, it's highest possible output, then we get:

`1.0 * (max - min) + min => max - min + min => max`

So, the highest number we can get is *max.*

Let's see this same pattern repeated with *Random#nextInt* in the next section.

An instance of *java.util.Random* can be also used to do the same.

Let's make use of the *java.util.Random.nextInt *method to get a random number:

```
public int getRandomNumberUsingNextInt(int min, int max) {
Random random = new Random();
return random.nextInt(max - min) + min;
}
```

The *min* parameter (the origin) is inclusive, whereas the *max*, the bound, is exclusive

**The java.util.Random.ints method returns an IntStream of random integers.**

So, we can utilize the *java.util.Random.ints* method and return a random number:

```
public int getRandomNumberUsingInts(int min, int max) {
Random random = new Random();
return random.ints(min, max)
.findFirst()
.getAsInt();
}
```

Here as well, the specified origin *min* is inclusive and *max* is exclusive.

In this article, we saw alternative ways of generating random numbers within a range.

Code snippets, as always, can be found over on GitHub.