Random Number Generation in Java

Random number generation is an important and necessary topic. Indeed, it will come in handy for you on countless occasions.

For example:

when completing a group of random numbers

when shuffling a pack of cards

when selecting a random element of a sequence

etc.

There are several waysto generate a random number. In this article, we will cover generation by means of Math.random().

In the Java class library, there is a package called "java.lang" and inside of it is the Math class. And inside the Math class is the random() method. Please see the picture below.

So, a random number is generated every time you summon Math.random() by means of the special algorithm (on the particular instruction). Is it possible to predict which number will be generated? In theory, it is possible, but it’s really hard to do. And since there is a small chance to predict which number will be generated, such numbers are calledpseudorandom, instead of just random.

You need to know three things:

1. By default, Math.random() generates real numbers from the interval [0;1), i.e. from 0 inclusive up to 1 exclusive.

“Up to 1 exclusive” means that Math.random cannot generate the number 1. But it can generate 0.999 – i.e. any number less than 1. Run this code on your computer and you will see that the console displays real numbers from 0 to any number less than 1.

1

2

3

4

5

6

7

publicclassTest{

publicstaticvoidmain(String[]args){

doublea=Math.random();

System.out.println(a);

}

}

So if you need to generate a random number from the interval [0;1), then you already know how to do it.

2. And what if we need to generate a number from a range which is not [0;1)?

It’s easy! Let’s formally write our range as [a;b) i.e. the lower limit is a, and the upper limit is b. Then, in order to generate a real number within the preset range we need to write the following:

( Math.random() * (b-a) ) + a

Let’s look at the examples below.

Example No. 1

So, in order to get a random real number within the range [0;3) (3 exclusively), we use the following:

1

2

3

4

5

6

7

publicclassTest{

publicstaticvoidmain(String[]args){

doublea=Math.random()*3;

System.out.println(a);

}

}

How does it work?

The range [0;1) is multiplied by 3. Accordingly,

The lower limit: 0*3=0

The upper limit: 1+3=3

We get the range: [0;3)

If we apply the formula, we get the following:

( Math.random() * (3 - 0) ) + 0 => Math.random() * 3

And this is what is displayed in the program.

Example No. 2

Let us suppose that we need to get a floating point number within the range [2;3) (3 exclusive).

3. And how do I generate an integer value?

Example No. 5

Let’s imagine that we need to generate a number in the range [0;2]. Please note that after the number 2, we used a square bracket instead of a round bracket. This means that we want the range to include the number 2. So how do we do it? Like this:

1

2

3

4

5

publicclassTest{

publicstaticvoidmain(String[]args){

inta=(int)(Math.random()*3);

}

}

How does it work?

Step No. 1: The interval [0;1) is multiplied by 3. Accordingly,

The lower limit: 0*3=0

The upper limit: 1*3=3

We got the range [0;3). The bracket after the number 3 is round. This means that the number 3 is not included in the range, i.e. 2.999 is the maximum number which can be generated in this range. In short, we are dealing with real (fraction) numbers.

Step No. 2: That's why we apply (int) before Math.random()*3. The fractional part is cut off and we get the range [0;2].

If we check our formula, we see it hasn't changed much.

If it's a real number and the upper limit includes b, then [a;b] :

( Math.random() * (b - a + 1) + a

And if it includes only the integer numbers:

(int)(( Math.random() * (b - a + 1) + a)

Example No. 6

We need to generate a number within the interval [3;4]. Please note that we used the square bracket after the number 4. This means that we want the range to include the number 4. So how do we do it? Like this:

1

2

3

4

5

publicclassTest{

publicstaticvoidmain(String[]args){

inta=3+(int)(Math.random()*2);

}

}

How does it work?

Step No. 1: We multiply the range [0;1) by 2. Accordingly,

The lower limit: 0*2=0

The upper limit: 1*2=2

We get the range [0;2). The bracket after the number 2 is round. That means that the number 2 is not included in the range, i.e. 1,999 is the maximum number which can be generated in this range. And it also means that we are dealing with a real (fraction) number.

Step No.2: That's why we apply (int) before Math.random()*3. The fractional part is cut off and we get the range [0;1]. Please note: now the range includes the number 1.

Step No.3: We add 3 to the interval [0;1]. Accordingly,

The lower limit: 0+3=3

The upper limit: 1+3=4

We got the new range [3;4].

Now we apply the formula:

(int)(Math.random() * (4 - 3 + 1) + 3) => (int)(Math.random() *2 + 3)

Example No. 7

We need an integer value within the range [-100; +100] (100 inclusive).

1

2

3

4

5

6

7

publicclassTest{

publicstaticvoidmain(String[]args){

inta=(int)(Math.random()*(200+1))-100;

System.out.println(a);

}

}

Example No. 8

We need an integer value within the range [-200; 400] (400 inclusive).