Core Java

How to Generate a Random Int in Java

This article shows how to generate a random Int or integer in Java using different approaches.

1. Introduction

Java has several ways to generate a random Integer, primitive or wrapped object, on its environment.

java random int

Here we’ll see some of these methods listed below:

  • Random class
  • Math class
  • ThreadLocalRandom class

2. Pre-requisites

The minimum Java version for execute this article’s example is JDK 8 (find here), but we can use the most recent released Java version (JDK 15).

Also, I’m using IntelliJ 2020.2, but you can use any IDE with support for versions recommended above.

3. Random class

The Random class is part of java.util package and is used to generate pseudo-random numbers in Java. Therefore, this is one simple approach to generates any type of number in Java as integer, double, float and so on.

Following we’ll see some methods that can be used to create a random integer:


int firstCounter = 0;
        System.out.println("Generating without range");
        while(firstCounter <3) {
            System.out.println(new Random().nextInt());

Random.nextInt() result

Generating without range

Literally, this is the most simple way to generate a random integer with Random class. So, the method nextInt() will use inner Random class next() method implementation to catch a integer for us.

A disadvantage (or advantage, depends on the use) of this method is that you can have any value for integer, varying from -2147483648 to 2147483647. However, if we want a more controlled range of integer, we can use the same method with a bound argument

Random.nextInt(int bound)

int secondCounter = 0;
        System.out.println("Generating with range");
        while(secondCounter <3) {
            System.out.println(new Random().nextInt(10));

Random.nextInt(int bound) result

Generating with range

As we can notice, the number does not vary above 10, how we determined in the method’s argument.

Note: The bound of nextInt() method must be positive (above zero)!

4. Math class

Here is what I think is the most famous way to generate a random number: the Math class.

Math class own a method random() that generates a pseudo-random double type number. Yes, I said double, that’s not the focus of this article.

But, We can write some lines of code as below to adapt our necessities:

Math.random() example

        int max = 10;
        int min = -10;
        int range = (max - min) + 1;
        System.out.println("Generating integer numbers with Math.random():");
        for (int i = 0; i < 5; i++) {
            int random = (int)(Math.random() * range) + min;

As we notice, first is created a range of maximum and minimum numbers. Further, we establish a range to convert the random result of Math class that we can control our double result.

Finally, we put a cast to the integer primitive (could be the Integer wrapper class too) to make the result stay in integer. The output of this code will be 5 random numbers between -10 and +10 as following:

Math.random() output

Generating integer numbers with Math.random():

5. ThreadLocalRandom class

ThreadLocalRandom class is a combination of the ThreadLocal and Random classes and is isolated to the current thread.

The difference between Random and ThreadLocalRandom is that Random class doesn’t perform well in a multi-thread environment. So, that’s why the ThreadLocalRandom was created.

ThreadLocalRandom simple example

System.out.println("Generating without range");
        while(firstCounter <3) {

We see above that we need to use ThreadLocalRandom.current() method to call the current thread. In addition, we use the nextInt() present in ThreadLocalRandom class and the result is some random numbers generated:

ThreadLocalRandom simple output

Generating without range

Another advantage for the use of ThreadLocalRandom is that we can use a range with negative numbers now:

ThreadLocalRandom with range example

int secondCounter = 0;
        System.out.println("Generating with range");
        while(secondCounter <3) {

And the result is as below:

ThreadLocalRandom with range output

Generating with range

6. Summary

In conclusion, we see some classes that we can use to generate random integer numbers in Java: Random, Math, and ThreadLocalRandom.

Moreover, we see what is needed to work with the generation properly and notice the different approaches and the kind of scenarios that we can use these generating methods.

7. Download the source code

You can download the full source code of this example here: How to Generate a Random Int in Java

Sergio Lauriano Junior

Sergio is graduated in Software Development in the University City of São Paulo (UNICID). During his career, he get involved in a large number of projects such as telecommunications, billing, data processing, health and financial services. Currently, he works in financial area using mainly Java and IBM technologies.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button