Updated July 5, 2023

## What is a Random Number in Java?

Random Numbers are commonly used in creating applications like Dice for a board game, Gambling Program, etc. Normally, random number generation takes a lot of time. But, in the Java programming language, this can be achieved using three ways. They are addressed in the below section Random Number Generator Functions in Java.

### Random Number Generator Functions in Java

In Java, Random Numbers can be generated using 3 ways:

- Math.random method
- java.util.Random class
- ThreadLocalRandom class

#### 1. Math.random() Method

Java Math class offers a number of methods to work on calculations such as logarithms, average, exponentiation, etc. random() is one of the methods among them that returns a positive double value within the range of 0.0 and 1.0 where 0.0 is inclusive, and 1.0 is exclusive. This method can be used with or without using parameters. If parameters are given, the random number generated will be within the given parameter’s range.

##### Example #1

**Code:**

```
public class RandomNumber {
double num; //Declare a variable num
//Method which generates a random number
public double randnum()
{
num=Math.random();
return num;
}
// Main Method of a program
public static void main(String[] args) {
//Printing a random number
System.out.println("Random Number generated inside main method: "+Math.random());
//Create an object of the class RandomNumber
RandomNumber randomobj=new RandomNumber();
//Store the return value obtained from randnum method in a variable randomval
double randomval=randomobj.randnum();
//Printing the random number stored in variable randomval
System.out.println("Random Number generated inside randomnumber method: "+randomval);
}
}
```

**Output:**

In the above Example, Random Number is generated using the Math.random() method in two ways-Directly applying it inside the main method and calling a method that contains Math.random() using the object. As mentioned in the explanation above, we can see that 2 random numbers are generated within the range of 0.0 and 1.0.

To generate a random number within the range of parameters, the general expression used is mentioned below:

**Math.random()* (( maxvalue – minvalue ) +1 ) + minvalue**

##### Example #2

Where maxvalue is the upper bound of the range and min value is the lower bound of the range. For Example, in order to generate a random number between 10 and 20, set the maxvalue as 20 and the minvalue as 10.

**Code:**

```
public class RandomNumParameters {
public double randomnum(double x,double y)//max value-y, min value-x
{
double z =(Math.random()*((y-x)+1)+x); //Formula for random number generation within a range
return z;
}
public static void main(String[] args)
{
RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters
double num=ran.randomnum(3.0, 10.0); //Call the Method
System.out.println("Random number generated within the range of 3 and 10: "+num );
} }
```

**Output:**

#### 2. java.util.Random Class

Java.util.random class generates random numbers of different data types such as float, long, integer, double, Boolean, etc. It is also possible to pass the range of numbers as arguments to generate a random number within that range. In order to use this class, the Random class of java.util must be imported (java.util.Random). Once this class is imported, create an instance and call the methods such as next long(), nextInt(), etc. using that instance.

##### Example

**Code:**

```
//Java program to generate Random numbers using Random class
package Sample;
import java.util.Random; //import Random Class
public class RandomNum {
public static void main(String[] args) {
Random rand=new Random(); //Create instance of Random class
double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable
System.out.println("Random Double value: "+ randomnum);
}
}
```

**Output:**

In the above program, a random double value is generated using the method nextDouble().

#### 3. ThreadLocalRandom class

ThreadLocalRandom class is a specialized type of Random class that is introduced in Java version 1.7. ThreadLocalRandom.current().nextInt() is one of the common methods that is used to generate random numbers. It is normally used in multi-threaded applications.

##### Example

**Code:**

```
//Java Program to generate random numbers using ThreadLocalRandom Class
import java.util.concurrent.ThreadLocalRandom;
public class RandomNumThread {
public static void main(String[] args) {
//print a random double
System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble());
}
}
```

**Output:**

### Generation of Integers

Random integers can be generated using the ThreadLocalRandom class and Random Class. In both cases, a method nextInt() is used for the same:

#### Example

**Code:**

```
//Java program to generate Random integer numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomInteger {
public static void main(String[] args) {
Random rnd=new Random(); //Create instance of Random class
int randomnum1=rnd.nextInt(); //Random Integer value using Random Class
int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30
int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class
System.out.println("Random Integer value using Random Class: "+ randomnum1);
System.out.println("Random Integer value within the range of 30: "+ randomnum2);
System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3);
}
}
```

**Output:**

In the above example, three Random integer type numbers are generated where one of the nextInt() method has 30 as an argument. So, while generating a random number, 30 will be set as the upper limit, and zero (default lower limit)will be set as the lower limit.

### Generating Float point Numbers

Similar to generating integer numbers, floating-point numbers can be generated using a method nextFloat(). This method can be used in both Random Class and ThreadLocalRandom Class:

#### Example

**Code:**

```
//Java program to generate Random Float numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomFloat {
public static void main(String[] args) {
Random rnd=new Random(); //Create instance of Random class
float randomnum1=rnd.nextFloat(); //Random Float value using Random Class
float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class
System.out.println("Random float value using Random Class: "+ randomnum1);
System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2);
}
}
```

**Output:**

### Conclusion – Random Number Generator in Java

Java contains a plethora of functions that can be used in programs. This helps in reducing the processing time and lines of code. Random Number Generation is one task where we can use some of these functions. This document covers the different methods to achieve this.

### Recommended Articles

This is a guide to Random Number Generator in Java. Here we discuss functions in java with examples and two different generators. You can also go through our other related articles to learn more –