Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

Randomness is a fascinating concept with applications in various fields such as cryptography, gaming, simulations, and machine learning. In computer systems, true randomness is elusive.

In Java, randomness is often generated using pseudorandom number generators (PRNGs). These generators aren’t truly random but rely on algorithms that produce sequences of numbers that appear random but are determined by a starting point, known as the seed.

In this tutorial, we’ll explore how these random seeds work in Java and uncover their role in random number generation. We’ll also discuss how different Java classes utilize these seeds to produce predictable sequences of random values and the implications of these mechanisms for various applications.

2. How Does the Random Class Work?

To generate a random number in Java, we use the Random class, which produces numbers that appear random. However, what we get is a pseudorandom number, meaning that while the sequence seems random, a deterministic algorithm generates it based on an initial input – the seed.

Many implementations of Random in programming languages, including Java, use the Linear Congruential Generator (LCG) algorithm. This algorithm generates a sequence of numbers based on a simple mathematical formula:

Xn+1 = (aXn + C) % m

Where Xn is the current value, Xn+1 is the next value, a is the multiplier, c is the increment, and m is the modulus. The initial value X0 is the seed.

The choice of a,c, and m can significantly impact the quality of the random numbers produced. Taking the remainder of mod m is similar to figuring out where a ball will end up on a rotating wheel with numbered sections.

For example, let’s take a sequence obtained when m=10 and X0 = a = c = 7 is

7,6,9,0,7,6,9,0,...

As seen in the above example, the sequence is not always random for all values of a, m, c, and X0.

3. The Role of the Seed

A seed is an initial input that starts the PRNG‘s process. The seed acts as a key that unlocks a specific sequence of numbers from a vast, predetermined set. Using the same seed will always produce the same sequence of numbers. For example, initializing a Random object with a seed of 35 and asking it to generate 12 random numbers will result in the same sequence each time we run the code:

public void givenNumber_whenUsingSameSeeds_thenGenerateNumbers() {
    Random random1 = new Random(35);
    Random random2 = new Random(35);

    int[] numbersFromRandom1 = new int[12];
    int[] numbersFromRandom2 = new int[12];

    for(int i = 0 ; i < 12; i++) {
        numbersFromRandom1[i] = random1.nextInt();
        numbersFromRandom2[i] = random2.nextInt();
    }
assertArrayEquals(numbersFromRandom1, numbersFromRandom2); }

This property is crucial in situations where we need predictable results for testing or debugging, simulations, and cryptography, but it also allows for randomness when desired.

4. The Default Seed in Java

We can create a Random class object without specifying a seed, and Java will use the current system time as the seed. Internally, the Random class calls its constructor that takes a long seed parameter, but it computes this seed based on the system time.

This approach offers a degree of randomness, but it’s not perfect. The system time is relatively predictable, and it’s possible for two Random objects to be created at nearly the same time to have similar seeds, leading to correlated random sequences.

We can use System.nanoTime() to obtain a more precise and less predictable seed. However, even this approach has limitations. For a truly unpredicted number, we need to use a cryptographic random number generator (CSPRNG) or a hardware-based random number generator (HRNG).

Let’s take a look at how we can use System.nanoTime() as a seed:

public void whenUsingSystemTimeAsSeed_thenGenerateNumbers() {
    long seed = System.nanoTime();
    Random random = new Random(seed);
 
    for(int i = 0; i < 10; i++) {
        int randomNumber = random.nextInt(100);
        assertTrue(randomNumber >= 0 && randomNumber < 100);
    }
}

5. Beyond the Random Class

We can use the Random class to generate random numbers in Java easily. However, there are other options available. Some are better suited for applications that need high-quality or cryptographically secure random numbers.

5.1. SecureRandom

Standard JDK implementations of java.util.Random uses a Linear Congruential Generator (LCG) algorithm to provide random numbers. The problem with this algorithm is that it’s not cryptographically strong. In other words, the generated values are much more predictable, therefore attackers could use it to compromise our system.

To overcome this issue, we should use java.security.SecureRandom in any security decisions.

5.2. ThreadLocalRandom

The Random class doesn’t perform well in a multi-threaded environment. In a simplified way, the reason for the poor performance of Random in a multi-threaded environment is contention – given that multiple threads share the same Random instance.

To address that limitation, Java introduced the java.util.concurrent.ThreadLocalRandom class in JDK 7 – for generating random numbers in a multi-threaded environment.

6. Conclusion

In this article, we see that seeds play a key role in controlling the behavior of the Random class. We also observe how using the same seed consistently produces the same sequence of random numbers, resulting in identical outputs.

When we understand the role of random seeds and the algorithms behind them, we can make informed choices about generating random numbers in our Java applications. This helps us ensure they meet our specific needs for quality, reproducibility, and security.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW