# Best way to generate Random numbers in Java | Beginners Guide

## Math.random() - Quick & Simple, Random class - More control and performance, ThreadLocalRandom Class - For multi threaded applications

Getting straight to the point, to generate a random number in Java, you can use the java.util.Random class. Given below are some detailed methods which you can choose according to your application's complexity.

## Using Random Class

Here's an example:`import java.util.Random;`

`Random random = new Random(); //Instance of the Random class`

`int randomNumber = random.nextInt(100);`

`// Generates a random integer between 0 and 99`

You can change the bound (Parameter of nextInt method, 100 in this example) to generate random numbers within a different range, and you can also use other methods provided by the `Random`

class to generate different types of random values, such as nextDouble(), nextFloat().

To generate a random integer between min and max(inclusive), you can use the following code:`random.nextInt(max - min) + min;`

For example :`Random random = new Random();`

`int randomNumber = random.nextInt(100) + 1;`

`//range 1(inclusive)-100(inclusive)`

## Using Math.random()

`Math.random()`

is a simple way to generate a random double between 0 (inclusive) and 1 (exclusive).

`int a = (int)Math.random() * (max - min + 1) + min`

`//to get int, use type casting`

However, `java.util.Random`

provides a more flexible and powerful way to generate random numbers. Here are a few reasons why `java.util.Random`

**might be preferred over** `Math.random()`

:

Customization:

`java.util.Random`

allows you to customize your random number generation by specifying a seed, which can be useful for testing and debugging. It also provides methods for generating random numbers of different data types (e.g., integers, longs, floats, and doubles).Reproducibility: If you want to generate the same sequence of random numbers repeatedly, you can use the

`setSeed()`

method of`java.util.Random`

to specify a seed value. (See more on seed value below)Thread safety:

`java.util.Random`

is designed to be thread-safe, meaning that multiple threads can use the same instance of`Random`

without interfering with each other.Performance: In some cases, the

`Random`

class can be faster than`Math.random()`

. The`Math.random()`

method uses an instance of`Random`

internally, but it also does some additional calculations to scale the result to the desired range.

## Using ThreadLocalRandom Class

It is a sub-class of the Random class. It has its seed, which cannot be changed.

The ThreadLocalRandom class provides better performance in multi-threaded applications it makes it easier for threads to access different random number generators and avoid getting in each other's way.

Note: Here I have not focused much on how to use Math.Random and ThreadLocalRandom.

### Pseudorandom Numbers

A pseudorandom number is a number that appears to be random but is generated using a deterministic algorithm. It's not truly random because it doesn't depend on a random physical process, but for all practical purposes, it's unpredictable and appears random.

All the above-discussed methods generate pseudorandom numbers and not truly random numbers.

### Math.random() vs Random Class vs ThreadLocalRandom Class

If you just need a quick and simple way to generate a random number, `Math.random()`

is likely enough. However, if you need more control over the generation process or a large number of random numbers for use in a performance-critical application, `java.util.Random`

is the better option and is suitable for both single-threaded and multi-threaded applications, and `ThreadLocalRandom`

class is recommended for use in multi-threaded applications due to its better performance.

### Seed value :

In the context of random number generation, a seed value is an initial value used to initialize the random number generator. The seed value is used to determine the sequence of numbers generated by the random number generator.

The sequence of random numbers generated by a random number generator is a deterministic sequence of numbers, meaning that given the same seed value, the same sequence of random numbers will be generated every time.

The seed value can be any integer value. If you do not specify a seed value when you create a new instance of a random number generator, Java will use the current time as the default seed value, so you will get a different sequence of random numbers each time you run the program.