There's no such thing as Random Numbers (for now)

To generate random numbers in Java, you do something like this:

1
import java.util.Random;
2

3
public class Main {
4
    public static void main(String[] args) {
5
        Random random = new Random();
6
        System.out.println(random.nextInt()); // outputs some random number
7
    }
8
}

You can also pass a seed to the Random class constructor, which directly affects the sequence of generated numbers.

1
import java.util.Random;
2

3
public class Main {
4
    public static void main(String[] args) {
5
        Random random = new Random(123);
6
        System.out.println(random.nextInt());
7
        System.out.println(random.nextInt());
8
        System.out.println(random.nextInt());
9
    }
10
}

Well, these numbers aren’t truly random. Let’s take a look at how the Random class works.

1
private static final long multiplier = 0x5DEECE66DL;
2
private static final long addend = 0xBL;
3
private static final long mask = (1L << 48) - 1;
4

5
public Random() {
6
    this(seedUniquifier() ^ System.nanoTime());
7
}
8

9
public int nextInt() {
10
    return next(32);
11
}
12

13
protected int next(int bits) {
14
    long oldseed, nextseed;
15
    AtomicLong seed = this.seed;
16
    do {
17
        oldseed = seed.get();
18
        nextseed = (oldseed * multiplier + addend) & mask;
19
    } while (!seed.compareAndSet(oldseed, nextseed));
20
    return (int)(nextseed >>> (48 - bits));
21
}

1. If no seed is passed to the constructor, the seed is automatically generated based on the current timestamp.
2. The nextInt method calls the next method, passing the number of bits of an Integer.
3. The next method then calculates the next seed using a linear congruential generator (LCG) formula.
4. The most significant bits are returned, using a right shift of 48 - 32 bits.

Using the same seed and the same algorithm will produce the same sequence of numbers

You can test this code on your own, and you will see the same sequence as me.

1
import java.util.Random;
2

3
public class Main {
4
    public static void main(String[] args) {
5
        long seed = 1000;
6
        Random random1 = new Random(seed);
7
        Random random2 = new Random(seed);
8

9
        for (int i = 0; i < 4; i++) {
10
          System.out.println(random1.nextInt() + "  " + random2.nextInt());
11
        }
12
    }
13
}

Output:

-1244746321  -1244746321
1060493871  1060493871
-1826063944  -1826063944
1976922248  1976922248

Other interesting Random Number Algorithms

Perlin Noise

The difference with this algorithm is that the sequence “makes sense,” having a smooth transition from one number to another. This makes it useful for generating textures, effects, and even game worlds.

Gaussian Distribution

With this algorithm, the probability of each number occurring follows a normal distribution, based on its distance from the mean.

I created two sketches with p5.js to showcase the difference between 3 random number generators:

• https://editor.p5js.org/iedoduarte1/sketches/vg4HQSOWB
• https://editor.p5js.org/iedoduarte1/sketches/EPBJI0eeq

There is much more out there, and I encourage you to check them out.

And FYI, REAL random numbers generators would exist if we had quantic computing power.