In this post, we will see how to generate pseudorandom numbers in Java. Before that, we will see what is Random numbers.

Random numbers are the * numbers* that occur in sequence such that the values are uniformly distributed over a defined interval or set, which is impossible to predict future values based on present and past value. Also it should pass a bunch of statistical tests. Random Number are important in statistical analysis and probability theory.

Algorithm used for generating the random number is called *Random Number Generator (RNG)*

There are two types of random numbers –

- Pseudo Random Number (PRN)
- Cryptographically Secure Pseudo Random Number (CSPRN)

## 1. PseudoRandom Number (PRN)

** Pseudorandom Number Generator (PRNG) **is an implementation of an algorithm that produces the number in the sequence that is uniformly distributed numbers which looks random, but is in fact deterministic (the sequence is generated from some unknown internal state), hence pseudorandom.

When you use Pseudorandom numbers in statistics, the only thing you care about is the sequence of numbers you get from generator passes the bunch of statistical test and whether it’s distributed like random numbers.

In Java there are 3 ways to generate the pseudorandom Number as below –

- Math.random()
- util.Random.nextInt()
- util.Random.ints() [ Java 8]

### 1.1 Math.random()

In java Math.random() method by default generates the random double number between 0.0 to 1.0 by calling the method as shown in below java code.

```
/**
* Created on Nov 19, 2016 Copyright(c) https://kodehelp.com All Rights Reserved.
*/
package com.kodehelp.util;
/**
* @author https://kodehelp.com
*/
public class PseudoRandomNumber {
public static void main(String args[]) {
System.out.println(Math.random());
}
}
```

If you want integer numbers in a specified range using Math.random() method then you can use the approach shown in the below java code.

```
/**
* Created on Nov 19, 2016 Copyright(c) https://kodehelp.com All Rights Reserved.
*/
package com.kodehelp.java.util;
/**
* @author https://kodehelp.com
*/
public class PseudoRandomNumber1 {
public static void main(String args[]) {
int MIN = 1001;
int MAX = 100001;
for (int i = 0; i < 10; i++) {
System.out.println((int) (Math.random() * ((MAX - MIN) + 1)) + MIN);
}
}
}
```

Note:Math.random() uses Random.nextDouble() internally and Random.nextDouble() uses Random.next() twice to generate a double number that has approximately uniformly distributed bits in its mantissa, so it is uniformly distributed in the range 0 to 1-(2^-52).

### 1.2 java.util.Random

`java.util.Random`

class used to generate a stream of pseudorandom numbers. As per the Oracle Java documentation, this class uses a 48-bit seed, which is modified using a linear congruential formula. Instances of java.util.Random is threadsafe. However, the concurrent use of the same java.util.Random instance across threads may encounter contention and consequent poor performance. Consider instead using ThreadLocalRandom in multithreaded designs.

`java.util.Random().nextInt()`

generates a pseudorandom integer number uniformly distributed int value from this random number generator’s sequence. The general contract of nextInt is that one int value is pseudorandomly generated and returned. All 2³² possible int values are produced with (approximately) equal probability.

`java.util.Random().nextInt(int bound)`

generates a pseudorandom integer number from 0 (inclusive) to bound (exclusive).

See below java code for `Random().nextInt()`

and `Random.nextInt(int bound)`

```
/**
* Created on Nov 19, 2016 Copyright(c) https://kodehelp.com All Rights Reserved.
*/
package com.kodehelp.java.util;
import java.util.Random;
/**
* @author https://kodehelp.com
*/
public class PseudoRandomNumber {
public static void main(String args[]) {
int bound = 100001;
Random r = new Random();
for (int i = 0; i < 10; i++) {
System.out.println(r.nextInt());
}
for (int i = 0; i < 10; i++) {
System.out.println(r.nextInt(bound));
}
}
}
```

### 1.3 java.util.Random().ints()

In Java 8, below new methods are added in java.util.Random class.

`public IntStream ints(int randomNumberOrigin, int randomNumberBound)`

`public IntStream ints(long streamSize, int randomNumberOrigin, int randomNumberBound)`

This `Random().ints(int origin, int bound)`

or `Random().ints(int min, int max)`

generates a random integer from origin (inclusive) to bound (exclusive).

See below java code for `Random().ints()`

example to generate random numbers in a given range –

```
/**
* Created on Nov 19, 2016 Copyright(c) https://kodehelp.com All Rights Reserved.
*/
package com.kodehelp.java.util;
import java.util.Random;
/**
* @author https://kodehelp.com
*/
public class GenerateRandomNumber {
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
System.out.println(getRandomNumberInRange(111, 200));
}
}
private static int getRandomNumberInRange(int randomNumberOrigin, int randomNumberBound) {
Random r = new Random();
return r.ints(randomNumberOrigin, (randomNumberBound + 1)).limit(1).findFirst().getAsInt();
}
}
```