Javatpoint Logo
Javatpoint Logo

How to Use Random Object in Java?

Java, one of the most widely used programming languages, offers a robust set of tools and libraries to developers. Among these, the java.util package provides a versatile and powerful class called Random. In this section, we will delve into the fascinating world of randomization in Java, exploring the Random class and its various applications.

Basics of Randomization

Randomization is a crucial aspect of many programming tasks, ranging from game development to data manipulation. In Java, the Random class plays a pivotal role in generating random values. To get started, let's explore the fundamentals of using Random objects.

Creating a Random Object

The first step is to instantiate a Random object. This can be achieved by simply creating an instance of the class:

Generating Random Numbers

Once we have a Random object, we can use its methods to generate random values. The most common method is nextInt(), which returns a pseudorandom, uniformly distributed integer:

For generating random integers within a specified range, we can use:

Randomization in Different Data Types

Java's Random class provides methods for generating random values of various data types. Let's explore some of the commonly used ones.

Random Booleans

To generate random boolean values, we can use the nextBoolean() method:

Random Doubles and Floats

For random floating-point numbers, we can use nextDouble() and nextFloat():

Random Bytes

If we need random bytes, the nextBytes(byte[] bytes) method can be used:

Seeding the Random Generator

By default, the Random class is initialized based on the current time, which means the sequence of random numbers will be different in each program run. However, there are situations where we might want to produce the same sequence of random numbers. This is where seeding comes into play.

In this example, the Random object is initialized with a seed value, ensuring that the sequence of random numbers will be the same every time the program is executed with the given seed.

Utilizing Randomization

Simulating Dice Rolls

One classic application of randomization is simulating dice rolls. Consider a scenario where we want to simulate the roll of a six-sided die:

Shuffling Arrays

Another practical application is shuffling the elements of an array. Java provides the Collections.shuffle() method, which internally uses the Fisher-Yates shuffle algorithm. However, if you want to implement your own shuffling logic, you can utilize the Random class:

Random Sampling

Random sampling involves selecting a subset of elements from a larger collection. Using the Random class, we can easily implement random sampling:

Thread Safety Considerations

While the Random class is suitable for most applications, it's important to note that it is not thread-safe. If multiple threads access a single Random instance concurrently, it may lead to unpredictable behavior. In scenarios involving multithreading, consider

Generating Random Numbers with Constraints

In certain scenarios, we may need to generate random numbers that meet specific criteria or constraints. For example, generating a random even number within a given range. We can achieve this by manipulating the generated random number:

It ensures that the generated number is even by multiplying the randomly generated value by 2 and adding the minimum range.

Reproducible Randomization with Streams

Java 8 introduced the concept of streams, and the Random class integrates well with stream operations. If you want to generate a stream of random numbers or elements, we can use the ints(), doubles(), or longs() methods provided by the Random class:

It can be particularly useful when working with large datasets or conducting statistical simulations.

  • Seed for Reproducibility: When reproducibility is crucial, seed the random number generator with a specific value.
  • Thread Safety: If your application involves multiple threads, consider using ThreadLocalRandom or synchronizing access to the Random instance to avoid potential issues.
  • SecureRandom for Security: For security-sensitive applications, opt for SecureRandom to ensure cryptographically secure randomization.
  • Streams for Conciseness: Leverage streams for concise and expressive generation of random values in certain scenarios.

Below is a complete Java program that demonstrates the usage of the Random class, including input, output, and comments explaining each step.


Enter seed value for randomization: 123
Random Integer: -147081396
Random Integer in Range [1, 100]: 56
Random Boolean: true
Random Double: 0.7722950494424231
Random Float: 0.43232417
Random Bytes: 38 127 -96 7 -63 
Simulated Dice Roll: 4
Shuffled Array: [5, 2, 3, 1, 4]
Random Sampled List: [8, 1, 6]

In this comprehensive guide, we explored the capabilities of the Random class in Java, covering basic usage, generating random values for different data types, seeding, and practical applications in scenarios like simulating dice rolls, shuffling arrays, and random sampling. Understanding how to use random objects in Java is a valuable skill for developers working on a wide range of projects.

Whether we are building games, implementing algorithms, or conducting simulations, the Random class provides a flexible and powerful tool for introducing randomness into your applications. By mastering the art of randomization, we can add a dynamic and unpredictable element to our Java programs, enhancing their functionality and realism.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA