Computer generated random numbers are divided into two categories: true random numbers and pseudo-random numbers.

True random numbers are generated based on external factors. For example, generating randomness using surrounding noises.

But generating such true random number is a time consuming task. Therefore, we can utilize pseudo-random numbers which are generated using an algorithm and a seed value.

These pseudo-random numbers are sufficient for most purposes. For example, you can use them in cryptography, in building games such as dice or cards, and in generating OTP (one-time password) numbers.

In this article, we will learn how to generate pseudo-random numbers using Math.random() in Java.

1. Use Math.random() to Generate Integers

Math.random() returns a double type pseudo-random number, greater than or equal to zero and less than one.

Let's try it out with some code:

    public static void main(String[] args) {
        double randomNumber = Math.random();
        System.out.println(randomNumber);
    }
    // output #1 = 0.5600740702032417
    // output #2 = 0.04906751303932033

randomNumber will give us a different random number for each execution.

Let's say we want to generate random numbers within a specified range, for example, zero to four.

    // generate random numbers between 0 to 4
    public static void main(String[] args) {
        // Math.random() generates random number from 0.0 to 0.999
        // Hence, Math.random()*5 will be from 0.0 to 4.999
        double doubleRandomNumber = Math.random() * 5;
        System.out.println("doubleRandomNumber = " + doubleRandomNumber);
        // cast the double to whole number
        int randomNumber = (int)doubleRandomNumber;
        System.out.println("randomNumber = " + randomNumber);
    }
    /* Output #1
    doubleRandomNumber = 2.431392914284627
    randomNumber = 2
    */

When we cast a double to int, the int value keeps only whole number part.

For example, in the above code, doubleRandomNumber is 2.431392914284627 . doubleRandomNumber's whole number part is 2 and fractional part (numbers after the decimal point) is 431392914284627 . So, randomNumber will only hold the whole number part 2.

You can read more about the Math.random() method in the Java documentation.

Using Math.random() is not the only way to generate random numbers in Java. Next, we'll consider how we can generate random numbers using the Random class.

2. Use the Random Class to Generate Integers

In the Random class, we have many instance methods which provide random numbers. In this section, we will consider two instance methods, nextInt(int bound), and nextDouble().

How to use the nextInt(int bound) method

nextInt(int bound) returns an int type pseudo-random number, greater than or equal to zero and less than the bound value.

The bound parameter specifies the range. For example, if we specify the bound as 4, nextInt(4) will return an int type value, greater than or equal to zero and less than four. 0,1,2,3 are the possible outcomes of nextInt(4) .

As this is an instance method we should create a random object to access this method. Let's try it.

    public static void main(String[] args) {
        // create Random object
        Random random = new Random();
        // generate random number from 0 to 3
        int number = random.nextInt(4);
        System.out.println(number);
    }

How to use the nextDouble() method

Similar to Math.random() , the nextDouble() returns a double type pseudo-random number, greater than or equal to zero and less than one.

    public static void main(String[] args) {
        // create Random object
        Random random = new Random();
        // generates random number from 0.0 and less than 1.0
        double number = random.nextDouble();
        System.out.println(number);
    }

For more information, you can read the random class's Java documentation.

So which should random number method should you use?

Math.random() uses the random class. If we only want double type pseudo-random numbers in our application, then we can use Math.random() .

Otherwise, we can use the random class as it provides various methods to generate pseudo-random numbers in different types such as nextInt(), nextLong(), nextFloat() and nextDouble().

Thank you for reading.

Photo image by Brett Jordan on Unsplash

You can connect with me on Medium.

Happy Coding!