# How to Generate Random Numbers in Java

Updated on August 25, 2011

## Java Random Numbers Overview

I will introduce you to random numbers in Java. First I'll give you what you came here for: ready made examples, then I'll go behind the scenes of random number generation in Java. I will go over each method that generates a "random" number in Java. I will explain why the numbers generated are not really random, and how normal distribution is related to random numbers in Java.

So without much delay here is an example that covers every method of generating a Random number in standard Java (as of this writing JDK and JRE 6 are in their 22nd update release) installation on Windows (Note that a statement new java.util.Random is used when you call Math.random(), that's why all my examples use use java.util.Random package).

## Java Random Numbers Code Sample

```package MathRandom_Java;
import java.util.Random;

public class Java_Math_Random_All
{
public static void main( String...strings )
{
// Create a new instance or object of class Random
Random util_Random = new Random();

// Generate a pseudorandom number between 0.0 and 1.0
// (Note: number will in the range of 0.0 to 1.0, but never 1.0)
double  util_Random_Double  = util_Random.nextDouble();

// Returns the next pseudorandom, Gaussian ("normally") distributed
// double value with mean 0.0 and standard deviation 1.0
double  util_Random_Gaussian  = util_Random.nextGaussian();

// Generate a number between 1.40129846432481707e-45
// to 3.40282346638528860e+38 (positive or negative)
float   util_Random_Float  = util_Random.nextFloat();

// Generate a number between -9,223,372,036,854,775,808
// to +9,223,372,036,854,775,807
long    util_Random_Long  = util_Random.nextLong();

// Generate a number between -2,147,483,648 to 2,147,483,647
int     util_Random_Integer  = util_Random.nextInt();

// Generate an integer from a specified range (if your pass
// in n as a parameter you numbers will range from 0 to n-1)
int     util_Random_Integer_from_n = util_Random.nextInt(32);

// Generate either true or false pseudorandomly
boolean util_Random_Bool = util_Random.nextBoolean();

// Create and initialize an array of 5 bytes
byte[] bytes = new byte[5];
// Populate the array with 5 randomly generated bytes
// Note: byte is a value that ranges from -128 to 127
util_Random.nextBytes( bytes );

// Creates a java.util.Random object and calls
// the nextDouble() method
double math_Random = Math.random();

// Display all the results from above methods
System.out.println( "Math.random() -> " + math_Random );

System.out.println( "nextDouble() ->" + util_Random_Double );
System.out.println( "nextGaussian() -> " + util_Random_Gaussian );
System.out.println( "nextFloat() -> " + util_Random_Float );
System.out.println( "nextLong() -> " + util_Random_Long );
System.out.println( "nextInt() -> " + util_Random_Integer );
System.out.println( "nextInt(n) -> " + util_Random_Integer_from_n );
System.out.println( "nextBoolean() -> " + util_Random_Bool );
System.out.println( "nextBytes(bytes) -> " );
for( int i = 0; i < bytes.length; i++ )
System.out.println( "Byte " + (i+1) + ": " + bytes[i] );
}
}```

## Sample Output

Math.random() -> 0.008014059073862545
nextDouble() -> 0.4017283520137178
nextGaussian() -> -0.5345105808614735
nextFloat() -> 0.6654831
nextLong() -> 982543587599054257
nextInt() -> -502464678
nextInt(n) -> 3
nextBoolean() -> true
nextBytes(bytes) ->
Byte 1: 62
Byte 2: -83
Byte 3: -93
Byte 4: 114
Byte 5: -109

## nextInt

First notice that depending on your needs, all you may be looking for is generating a simple random integer in the range of your choosing.

For that purpose I recommend that you use nextInt(int n) method. Just remember that if you want to generate numbers from 0 to n pass a number that is equal n + 1.

For example if I want to generate numbers in the range of 0 to 32 I would pass 33 like so: nextInt(33)

And if I wanted to limit my lower range, I would add a number to what I generate from nextInt(int n), and subtract the same number from n. For example nextInt(33-10)+10 would generate numbers in the range of 10 to 32.

## nextInt Code Sample

```package MathRandom_Java;
import java.util.Random;

public class Java_Math_Random_Int
{
public static void main( String...strings )
{
// Create a new instance or object of class Random
Random util_Random = new Random();

// Generate an integer from a specified range (if your pass
// in n as a parameter your numbers will range from 0 to n-1)
int pseudorandom_Integer = util_Random.nextInt(32+1);
System.out.println( "nextInt( n ) -> " + pseudorandom_Integer );

// Generate an integer from 10 inclusive to 32 exclusive.
pseudorandom_Integer = util_Random.nextInt(33-10) + 10;
System.out.println( "nextInt( n-10 ) + 10 -> " + pseudorandom_Integer );
}
}```

## Sample Output

nextInt( n ) -> 27
nextInt( n-10 ) + 10 -> 16

## Java Random is Not Random

Generating a random number on a computer is not random at all. There is an algorithm that takes number of milliseconds that have passed starting from UNIX epoch. Since the number of milliseconds always changes, a number generated from the numerous random methods in Java, seems to be random.

If you were to manually pass in the number of milliseconds (a seed value) to the Random class instance or object, you would see that every time you generate a "random" value you get the same result! Run this code repeatedly to see what I mean:

```package MathRandom_Java;
import java.util.Random;

public class Java_Math_Random_Seed
{
public static void main( String...strings )
{
// Create a new instance or object of class Random
Random util_Random = new Random();
// If you manually set the seed for your Random object,
// the value generated will be the same on each run.
util_Random.setSeed( 555 );

// Generate a pseudo random number between 0.0 and 1.0
// (Note: number will be in the range of 0.0 to 1.0,
// but never 1.0)
double  util_Random_Double  = util_Random.nextDouble();

System.out.println( "nextDouble() ->" + util_Random_Double );
}
}```

## Sample Output - The Same on All Computers

nextDouble() ->0.6816084544091354

## Uniform vs Normal Distributions in Java Random Methods

Another point to consider is that almost all random methods in Java use uniform distribution method for the their values. Which in plain English means that the probability to select a pseudo random number from all the possible random numbers that a computer can produce is going to be the same.

The exception to this rule is the method called nextGausian() which generates a pseudo random number based on normal distribution. Translation into simpler language yields: values generated from nextGausian() are biased toward the most probable, and he most probably is 0. For example 0.5 is much much more probable to appear to be generated from nextGaussian() than say 0.0005.

## Normal Distribution Blurb

It forms a bell shaped curve, which is also called a normal curve. Almost everything in nature (including human behavior, like watching TV) occurs according to this normal curve (if measured and graphed).

The normal curve could by itself take up a lot of volumes of writing and is not going to be covered in this article, so suffice it to say that if you wanted to make an application that would simulate a Natural behavior you would use nextGaussian() method.

## Last Words

To sum it all up, there three basic things you have to be aware of when generating pseudo random values:

1. Most methods use uniform distribution, but there is one method that uses normal or Gaussian distribution called nextGaussian().
2. If you simply want to generate a pseudo random range of positive integers from zero to some number n then use nextInt( n+1 ).
3. Alternatively if you want to generate a pseudo random range of positive integers from some number m to some number n, then use nextInt(n-m)+m, given that m is less than n.

0

75

3

32

6