Java Random – Constructors & Methods – Examples

Java Random

Java Random class instance is used to generate a stream of pseudorandom numbers.

In this tutorial, we will learn about he constructors and methods of Java Random class with example programs.

Java Random Class Constructors

There are two constructors to instantiate a Random class object.

1. Random()

Random() creates a new random number generator.

In the following example, we create an instance of Random class using Random() constructor.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    }
}

2. Random(long seed)

Random() creates a new random number generator using the specified seed.

In the following example, we create an instance of Random class using Random(seed) constructor.

Java Program

import java.util.Random;

public class Example {  
	public static void main(String[] args) {
		long seed = 412;
		Random random = new Random(seed);  
	}  
}

Java Random Class Methods

1. doubles()

Random.doubles() returns an effectively unlimited stream of pseudorandom double values, each between zero (inclusive) and one (exclusive).

In the following example, we will generate an unlimited sequence of random double-precision floating point numbers using doubles() method and print out four of them to the console.

Java Program

import java.util.Random;
import java.util.function.DoubleConsumer;
import java.util.stream.DoubleStream;  

public class Example {  
	public static void main(String[] args) {  
		Random random = new Random();  
		DoubleStream ds = random.doubles();  

		ds.limit(4).forEach(new DoubleConsumer() {
			@Override
			public void accept(double value) {
				System.out.println(value);
			}
		});
    }  
}

Output

0.14584589858798724
0.01596337682890825
0.4461234706535546
0.5966428933676975

2. doubles(double randomNumberOrigin, double randomNumberBound)

Random.doubles() Returns an effectively unlimited stream of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).

In the following example, we will generate an unlimited sequence of random double-precision floating point numbers, which are limited by an origin and bound using doubles() method and print out four of these numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.DoubleConsumer;
import java.util.stream.DoubleStream;  

public class Example {  
	public static void main(String[] args) {  
		double randomNumberOrigin = 1;  
		double randomNumberBound = 7;  
		Random random= new Random();  
		DoubleStream ds = random.doubles(randomNumberOrigin, randomNumberBound);  
 
		ds.limit(4).forEach(new DoubleConsumer() {
			@Override
			public void accept(double value) {
				System.out.println(value);
			}
		});
    }  
}  

Output

4.124126976639339
6.277075813743702
2.9896554435576643
1.6867903457923643

3. doubles(long streamSize)

Random.doubles() returns a stream producing the given streamSize number of pseudorandom double values, each between zero (inclusive) and one (exclusive).

In the following example, we will generate an specific number of random double-precision floating point numbers, using doubles(streamSize) method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.DoubleConsumer;
import java.util.stream.DoubleStream;  

public class Example {  
	public static void main(String[] args) {  
		long streamSize = 5;  
		Random random = new Random();
		DoubleStream ds = random.doubles(streamSize);
		
		ds.forEach(new DoubleConsumer() {
			@Override
			public void accept(double value) {
				System.out.println(value);
			}
		});
    }  
} 

Output

0.24585762538765643
0.8752279248291293
0.6706517385958398
0.47129774709285743
0.8528845262464368

4. doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)

Random.doubles() returns a stream producing the given streamSize number of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).

In the following example, we will generate eight random double-precision floating point numbers which are limited by an origin and bound using doubles() method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.DoubleConsumer;
import java.util.stream.DoubleStream;  

public class Example {  
	public static void main(String[] args) {  
		double randomNumberOrigin = 1;  
		double randomNumberBound = 7;  
		long streamSize = 8;  
		Random random = new Random();
		DoubleStream ds =random.doubles(streamSize,randomNumberOrigin,randomNumberBound);  
		
		ds.forEach(new DoubleConsumer() {
			@Override
			public void accept(double value) {
				System.out.println(value);
			}
		});
    }  
}

Output

2.392701685665302
2.9381978153219777
3.69356795462521
6.0812621302928305
5.793783278818572
5.451979737142773
1.8253898408924665
2.54037873488756

5. ints()

Random.ints() returns an effectively unlimited stream of pseudorandom int values.

In the following example, we will generate an unlimited sequence of random integers using ints() method and print out four of them to the console.

Java Program

import java.util.Random;
import java.util.stream.IntStream;
import java.util.function.IntConsumer;

public class Example {  
	public static void main(String[] args) {  
		Random random = new Random(); 
		IntStream ds = random.ints();

		ds.limit(4).forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		}); 
	}  
}

Output

1549243955
-654704097
-1217687007
1648661790

6. ints(int randomNumberOrigin, int randomNumberBound)

Random.ints() returns an effectively unlimited stream of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).

Java Program

import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;  

public class Example {  
	public static void main(String[] args) {  
		int randomNumberOrigin = 1;  
		int randomNumberBound = 7;  
		Random random= new Random();  
		IntStream ds = random.ints(randomNumberOrigin, randomNumberBound);  

		ds.limit(5).forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		});
	}  
}

Output

2
2
1
1
5

7. ints(long streamSize)

Random.ints() returns a stream producing the given streamSize number of pseudorandom int values.

In the following example, we will generate eight random integers using ints(streamSize) method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;  

public class Example {  
	public static void main(String[] args) {  
		int streamSize = 8;
		Random random = new Random();  
		IntStream ds = random.ints(streamSize);  

		ds.forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		});
	}  
}

Output

790793602
-445498747
-322809516
1575745272
732465345
586364815
1791511337
-1366525847

8. ints(long streamSize, int randomNumberOrigin, int randomNumberBound)

Random.ints() Returns a stream producing the given streamSize number of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).

In the following example, we will generate eight random integers which are limited by an origin 1 and bound 7 using ints() method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;  

public class Example {  
	public static void main(String[] args) {  
		int streamSize = 8;
		int randomNumberOrigin = 1;  
		int randomNumberBound = 7;  
		Random random = new Random();  
		IntStream ds = random.ints(streamSize, randomNumberOrigin, randomNumberBound);  

		ds.forEach(new IntConsumer() {
			@Override
			public void accept(int value) {
				System.out.println(value);
			}
		});
	}  
}

Output

4
6
2
5
5
3
3
2

9. longs()

Random.longs() returns an effectively unlimited stream of pseudorandom long values.

In the following example, we will generate an unlimited sequence of random long type numbers using longs() method and print out four of them to the console.

Java Program

import java.util.Random;
import java.util.function.LongConsumer;
import java.util.stream.LongStream;  

public class Example {  
	public static void main(String[] args) {  
		Random random = new Random();  
		LongStream ds = random.longs();  

		ds.limit(4).forEach(new LongConsumer() {
			@Override
			public void accept(long value) {
				System.out.println(value);
			}
		});
	}  
}

Output

-6251239855392854015
-7974780473092051021
-2652163404078734145
7738474359912325515

10. longs(long streamSize)

Random.longs() returns a stream producing the given streamSize number of pseudorandom long values.

In the following example, we will generate an specific number of long values, say eight, using longs(streamSize) method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.LongConsumer;
import java.util.stream.LongStream;  

public class Example {  
	public static void main(String[] args) {  
		long streamSize = 8;
		Random random = new Random();  
		LongStream ds = random.longs(streamSize);  

		ds.forEach(new LongConsumer() {
			@Override
			public void accept(long value) {
				System.out.println(value);
			}
		});
	}  
}

Output

-6830441378515779608
-1179248027058137291
-5606058920192108368
8178120771225726595
-3472126381625498085
7782182188885249485
-4504231265999262239
-4107022727140179889

11. longs(long randomNumberOrigin, long randomNumberBound)

Random.longs() returns an effectively unlimited stream of pseudorandom long values, each conforming to the given origin (inclusive) and bound (exclusive).

In the following example, we will generate an unlimited sequence of random long values, which are limited by an origin and bound using longs() method and print out four of these numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.LongConsumer;
import java.util.stream.LongStream;  

public class Example {  
	public static void main(String[] args) {  
		long randomNumberOrigin = 154;  
		long randomNumberBound = 200;  
		Random random = new Random();  
		LongStream ds = random.longs(randomNumberOrigin, randomNumberBound);  

		ds.limit(4).forEach(new LongConsumer() {
			@Override
			public void accept(long value) {
				System.out.println(value);
			}
		});
	}  
}

Output

188
174
194
188

12. longs(long streamSize, long randomNumberOrigin, long randomNumberBound)

Random.longs() returns a stream producing the given streamSize number of pseudorandom long, each conforming to the given origin (inclusive) and bound (exclusive).

In the following example, we will generate eight random numbers of type long which are limited by an origin and bound using longs() method and print out these random numbers from the stream to the console.

Java Program

import java.util.Random;
import java.util.function.LongConsumer;
import java.util.stream.LongStream;  

public class Example {  
	public static void main(String[] args) {  
		long streamSize = 8;
		long randomNumberOrigin = 154;  
		long randomNumberBound = 200;  
		Random random = new Random();  
		LongStream ds = random.longs(streamSize, randomNumberOrigin, randomNumberBound);

		ds.forEach(new LongConsumer() {
			@Override
			public void accept(long value) {
				System.out.println(value);
			}
		});
	}  
}

Output

192
172
155
170
179
157
188
197

13. next(int bits)

Random.next() returns the next pseudorandom number from this Random Generator’s sequence.

Random.next() is a protected method of Random class. So, to use this class, we may have to create a class, say Example with Random as its parent class. Since, Example is a child class of Random, Example can access protected class of Random.

Java Program

import java.util.Random;

public class Example extends Random{ 
    public static void main(String[] args) {
    	Example random = new Example();
		System.out.println(" Next Random Value : " + random.next(9));
		System.out.println(" Next Random Value : " + random.next(15));  
		System.out.println(" Next Random Value : " + random.next(32));  
		System.out.println(" Next Random Value : " + random.next(4));
    }
}

Output

 Next Random Value : 174
 Next Random Value : 10188
 Next Random Value : -776918100
 Next Random Value : 9

14. nextBoolean()

Random.nextBoolean() returns the next pseudorandom, uniformly distributed boolean value from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextBoolean() on this Random object to get the next random boolean value. We shall print it to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	boolean b = random.nextBoolean();
    	System.out.println("Next random boolean value is : " + b);
    }
}

Output

Next random boolean value is : true

15. nextBytes(byte[] bytes)

Random.nextBytes() generates random bytes and places them into a user-supplied byte array.

In the following example, we will create an object random of Random class type and a an empty byte array of size 10. We will call nextBytes() on this Random object and pass the empty byte array to the method as argument. The method loads this byte array with the randomly generated bytes.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	byte[] bytes = new byte[10];
    	random.nextBytes(bytes);
    	System.out.println("Random bytes : ");
    	for(byte b: bytes) {
    		System.out.println(b);
    	}
    }
}

Output

Random bytes : 
-61
91
69
107
-128
-69
-42
107
53
-102

16. nextDouble()

Random.nextDouble() returns the next pseudorandom, uniformly distributed double value between 0.0 and 1.0 from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextDouble() on this Random object to get the next random double value. We shall print it to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	double d = random.nextDouble();
    	System.out.println("Next random double value is : " + d);
    }
}

Output

Next random double value is : 0.2885113742924815

17. nextFloat()

Random.nextFloat() Returns the next pseudorandom, uniformly distributed float value between 0.0 and 1.0 from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextFloat() on this Random object to get the next random float value. We shall print it to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	float f = random.nextFloat();
    	System.out.println("Next random float value is : " + f);
    }
}

Output

Next random float value is : 0.9188673

18. nextGaussian()

Random.nextGaussian() returns the next pseudorandom, Gaussian (“normally”) distributed double value with mean 0.0 and standard deviation 1.0 from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextGaussian() on this Random object to get the next Gaussian double value. We shall print it to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	double g = random.nextGaussian();
    	System.out.println("Next random gaussian value is : " + g);
    }
}

Output

Next random gaussian value is : 0.05262116402960923

19. nextInt()

Random.nextInt() returns the next pseudorandom, uniformly distributed int value from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextInt() on this Random object to get the next integer value. We shall print it to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	int i = random.nextInt();
    	System.out.println("Next random integer value is : " + i);
    }
}

Output

Next random integer value is : 759359738

20. nextInt(int bound)

Random.nextInt() Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextInt(bound) on this Random object to get the next integer value within the number, bound. We shall print it to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	int bound = 100;
    	int i = random.nextInt(bound);
    	System.out.println("Next random integer value is : " + i);
    }
}

Output

Next random integer value is : 53

21. nextLong()

Random.nextLong() returns the next pseudorandom, uniformly distributed long value from this random number generator’s sequence.

In the following example, we will create an object random of Random class type. We will call nextLong() on this Random object to get the next long value. We shall print this long value to console.

Java Program

import java.util.Random;

public class Example{ 
    public static void main(String[] args) {
    	Random random = new Random();
    	long l = random.nextLong();
    	System.out.println("Next random long value is : " + l);
    }
}

Output

Next random long value is : 5015315584966125576

22. setSeed(long seed)

Random.setSeed() method sets the seed of this random number generator using a single long seed.

In the following example, we will create a Random class object and set the seed for this Random object.

Java Program

import java.util.Random;

public class Example {  
	public static void main(String[] args) {  
		Random random = new Random(); 
		long seed = 20;
		random.setSeed(seed);
		System.out.println("The seed is set for the random object.");
		System.out.println("Next Random Int : "+random.nextInt());  
    }  
}

Output

The seed is set for the random object.
Next Random Int : -1150867590

Conclusion

In this Java Tutorial, we have learnt the constructors and methods of Java Random class with the help of examples.