Java: Can (new Random()).nextInt(5) always return the same number?

Question

Sometimes this piece of code always returns the same number (and sometimes it works fine):

(new Random()).nextInt(5)

I have suspicions where the problem is - it probably always creates a new Random with the same seed. So what would be the best solution:

• create a static var for Random() and use it instead.
• use Math.random() * 5 (looks like it uses a static var internally)

or something else? I don't need anything fancy just something that looks random.

Also it would be helpful if someone can explain why the original code sometimes works and sometimes it doesn't.

Thanks.

Answer 1

The javadoc for java.util.Random is clear:

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers.

The default constructor is also clear:

Creates a new random number generator. This constructor sets the seed of the random number generator to a value very likely to be distinct from any other invocation of this constructor.

In other words, no guarantees.

If you need a more random algorithm, use java.security.SecureRandom.

Answer 2

...Sometimes this piece of code [..] returns the same number (and sometimes it works fine)...

So it works randomly??? :) :) :)

Ok, ok, downvote me now!!

Answer 3

If you're calling that line of code on successive lines, then yes, the two Random instances you're creating could be created with the same seed from the clock (the clock millisecond tick count is the default seed for Random objects). Almost universally, if an application needs multiple random numbers, you'd create one instance of Random and re-use it as often as you need.

Edit: Interesting note, The javadoc for Random has changed since 1.4.2, which explained that the clock is used as the default seed. Apparently, that's no longer a guarantee.

Edit #2: By the way, even with a properly seeded Random instance that you re-use, you'll still get the same random number as the previous call about 1/5 of the time when you call nextInt(5).

public static void main(String[] args) {
    Random rand = new Random();
    int count = 0;
    int trials = 10000;

    int current;
    int previous = rand.nextInt(5);

    for(int i=0; i < trials; ++i)
    {
        current = rand.nextInt(5);

        if( current == previous )
        {
            count++;
        }
    }

    System.out.println("Random int was the same as previous " + count +
                       " times out of " + trials + " tries.");
}