Here you will learn to generate random number in java between two given number by different means. I will try to provide cons for different mechanism so that you can choose what is best for you.

## 1- Math.random()

This method will always return number between 0(inclusive) and 1(exclusive). Simple tweak can be used to generate random number between give two numbers.

```
package com.jbt.random;
import java.util.Random;
/*
* Generate random number between given high and low number.
*/
public class generate_random_between_two_number {
public static void main(String[] args) {
// It will generate random number between 0 and 50
System.out.println((int) (Math.random() * 50));
/*
* Below code will generate random number
* between 10 and 50. ((int)
* (Math.random()*(maximum - minimum))) +
* minimum
*
* This is simple tweak which is used
* here. First we generate random number
* between 0 and (maximum - minimum)(40 in
* current scenario) and then adding
* minimum number after random number gets
* generated.
*
*/
System.out.println(
((int) (Math.random() * (50 - 10))) + 10);
}
}
```

#### Bullet Points :

- Internally it uses java.util.Random() to generate random numbers.
- First time when called, it creates random number generator and for future calls it uses nextDouble() method from random class.
- Method is synchronized hence multiple thread is accessing this to generate numbers it may reduce contention for each thread to have its own pseudorandom-number generator.
- For better performance for multi threaded environment you can use ThreadLocalRandom introduced in JDK 1.7.
- As Math.random internally uses nextDouble method, it will always return double number.
- In order to get Integer you have to cast the value to integer.

## 2- java.util.Random

```
package com.jbt.random;
import java.util.Random;
/*
* Generate random number between given high and low number.
*/
public class generate_random_between_two_number {
public static void main(String[] args) {
Random randomObj = new Random();
/*
* Below code will generate random number
* between 10 and 50. ((int)
* (Math.random()*(maximum - minimum))) +
* minimum
*
* This is simple tweak which is used
* here. First we generate random number
* between 0 and (maximum - minimum)(40 in
* current scenario) and then adding
* minimum number after random number gets
* generated.
*
* Max value is exclusive in case of
* nextInt to make it inclusive you need
* to add 1.
*/
int randomNum = randomObj.nextInt((50 - 10)) + 10;
System.out.println(randomNum);
}
}
```

#### Bullet Points:

- Same as above, Here contention problem will occur in case of multi threaded environment. As random is only used in case of Math.random.
- To overcome performance problem you can use ThreadLocalRandom.
- As opposed to Math.random, Random class have multiple methods for generating different type of numbers(e.g. int/double/long etc).
- There are multiple algorithms that can be used by random class for generating random numbers.
- For portability it is necessary to let random class use all algorithms available.
- Random class is not final meaning it can extended and extended class can use any specific algorithms to generate random number.

## 3- ThreadLocalRandom

ThreadLocalRandom extends Random class and provide enhancement for multi threaded environment.

```
package com.jbt.random;
import java.util.concurrent.ThreadLocalRandom;
public class ThreadLocalRandom_Example {
public static void main(String[] args) {
/*
* Returns random integer value between 0(Inclusive) and given value(exclusive).
*/
System.out.println(ThreadLocalRandom.current().nextInt(50));
// Returns random integer value between given numbers.
System.out.println(ThreadLocalRandom.current().nextInt(10, 50));
}
}
```

#### Bullet Point

- ThreadLocalRandom provides better performance than random in case of multi threaded environment.
- Explicit seed setting is not allowed.

## 4- Java 8

In java 8 some new methods have been included in Random class. Which can be used to generate random number without any hiccups. You can use Java 8 Lambda feature to get the result.

```
package com.jbt.random;
import java.util.Random;
/*
* Generate random integer between two given number using methods
* introduced in JDK 1.8.
*/
public class generate_random_between_two_number_jdk_8 {
public static void main(String[] args) {
Random randomObj = new Random();
System.out.println(randomObj.ints(10, 50).findFirst().getAsInt()); ;
}
}
```

Thanks!!

Rather than creating a class, I want to use the Math.random() between 2 specific numbers(say 48, 49). Any idea how can I do that?

min + (int) (Math.random() * (max-min)); // This generates random numbers from min(inclusive) to max(exclusive)

Therefore 48 + (int) (Math.random() * 2); //This generates random numbers between 48 and 49 (with both numbers being inclusive)