Added in API level 35

RandomGenerator

public interface RandomGenerator

java.util.random.RandomGenerator


The RandomGenerator interface is designed to provide a common protocol for objects that generate random or (more typically) pseudorandom sequences of numbers (or Boolean values). Such a sequence may be obtained by either repeatedly invoking a method that returns a single pseudorandomly chosen value, or by invoking a method that returns a stream of pseudorandomly chosen values.

Ideally, given an implicitly or explicitly specified range of values, each value would be chosen independently and uniformly from that range. In practice, one may have to settle for some approximation to independence and uniformity.

In the case of int, long, and boolean values, if there is no explicit specification of range, then the range includes all possible values of the type. In the case of float and double values, first a value is always chosen uniformly from the set of 2w values between 0.0 (inclusive) and 1.0 (exclusive), where w is 23 for float values and 52 for double values, such that adjacent values differ by 2w (notice that this set is a subset of the set of all representable floating-point values between 0.0 (inclusive) and 1.0 (exclusive)); then if an explicit range was specified, then the chosen number is computationally scaled and translated so as to appear to have been chosen approximately uniformly from that explicit range.

Each method that returns a stream produces a stream of values each of which is chosen in the same manner as for a method that returns a single pseudorandomly chosen value. For example, if r implements RandomGenerator, then the method call r.ints(100) returns a stream of 100 int values. These are not necessarily the exact same values that would have been returned if instead r.nextInt() had been called 100 times; all that is guaranteed is that each value in the stream is chosen in a similar pseudorandom manner from the same range.

Every object that implements the RandomGenerator interface by using a pseudorandom algorithm is assumed to contain a finite amount of state. Using such an object to generate a pseudorandomly chosen value alters its state by computing a new state as a function of the current state, without reference to any information other than the current state. The number of distinct possible states of such an object is called its period. (Some implementations of the RandomGenerator interface may be truly random rather than pseudorandom, for example relying on the statistical behavior of a physical object to derive chosen values. Such implementations do not have a fixed period.)

As a rule, objects that implement the RandomGenerator interface need not be thread-safe. It is recommended that multithreaded applications use either ThreadLocalRandom or (preferably) pseudorandom number generators that implement the SplittableGenerator or JumpableGenerator interface.

Objects that implement RandomGenerator are typically not cryptographically secure. Consider instead using SecureRandom to get a cryptographically secure pseudorandom number generator for use by security-sensitive applications. Note, however, that SecureRandom does implement the RandomGenerator interface, so that instances of SecureRandom may be used interchangeably with other types of pseudorandom generators in applications that do not require a secure generator.

Unless explicit stated otherwise, the use of null for any method argument will cause a NullPointerException.

Summary

Nested classes

interface RandomGenerator.ArbitrarilyJumpableGenerator

This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can easily jump forward, by an arbitrary amount, to a distant point in the state cycle. 

interface RandomGenerator.JumpableGenerator

This interface is designed to provide a common protocol for objects that generate pseudorandom values and can easily jump forward, by a moderate amount (ex. 

interface RandomGenerator.LeapableGenerator

This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can easily not only jump but also leap forward, by a large amount (ex. 

interface RandomGenerator.SplittableGenerator

This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can be split into two objects (the original one and a new one) each of which obey that same protocol (and therefore can be recursively split indefinitely). 

interface RandomGenerator.StreamableGenerator

The StreamableGenerator interface augments the RandomGenerator interface to provide methods that return streams of RandomGenerator objects. 

Public methods

default DoubleStream doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)

Returns a stream producing the given streamSize number of pseudorandomly chosen double values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

default DoubleStream doubles(long streamSize)

Returns a stream producing the given streamSize number of pseudorandomly chosen double values.

default DoubleStream doubles()

Returns an effectively unlimited stream of pseudorandomly chosen double values.

default DoubleStream doubles(double randomNumberOrigin, double randomNumberBound)

Returns an effectively unlimited stream of pseudorandomly chosen double values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

static RandomGenerator getDefault()

Returns a RandomGenerator meeting the minimal requirement of having an algorithm whose state bits are greater than or equal 64.

default IntStream ints(long streamSize)

Returns a stream producing the given streamSize number of pseudorandomly chosen int values.

default IntStream ints(int randomNumberOrigin, int randomNumberBound)

Returns an effectively unlimited stream of pseudorandomly chosen int values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

default IntStream ints()

Returns an effectively unlimited stream of pseudorandomly chosen int values.

default IntStream ints(long streamSize, int randomNumberOrigin, int randomNumberBound)

Returns a stream producing the given streamSize number of pseudorandomly chosen int values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

default boolean isDeprecated()

Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.

default LongStream longs(long streamSize)

Returns a stream producing the given streamSize number of pseudorandomly chosen long values.

default LongStream longs()

Returns an effectively unlimited stream of pseudorandomly chosen long values.

default LongStream longs(long randomNumberOrigin, long randomNumberBound)

Returns an effectively unlimited stream of pseudorandomly chosen long values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

default LongStream longs(long streamSize, long randomNumberOrigin, long randomNumberBound)

Returns a stream producing the given streamSize number of pseudorandomly chosen long values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

default boolean nextBoolean()

Returns a pseudorandomly chosen boolean value.

default void nextBytes(byte[] bytes)

Fills a user-supplied byte array with generated byte values pseudorandomly chosen uniformly from the range of values between -128 (inclusive) and 127 (inclusive).

default double nextDouble()

Returns a pseudorandom double value between zero (inclusive) and one (exclusive).

default double nextDouble(double bound)

Returns a pseudorandomly chosen double value between zero (inclusive) and the specified bound (exclusive).

default double nextDouble(double origin, double bound)

Returns a pseudorandomly chosen double value between the specified origin (inclusive) and the specified bound (exclusive).

default double nextExponential()

Returns a nonnegative double value pseudorandomly chosen from an exponential distribution whose mean is 1.

default float nextFloat(float origin, float bound)

Returns a pseudorandomly chosen float value between the specified origin (inclusive) and the specified bound (exclusive).

default float nextFloat()

Returns a pseudorandom float value between zero (inclusive) and one (exclusive).

default float nextFloat(float bound)

Returns a pseudorandomly chosen float value between zero (inclusive) and the specified bound (exclusive).

default double nextGaussian(double mean, double stddev)

Returns a double value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.

default double nextGaussian()

Returns a double value pseudorandomly chosen from a Gaussian (normal) distribution whose mean is 0 and whose standard deviation is 1.

default int nextInt(int origin, int bound)

Returns a pseudorandomly chosen int value between the specified origin (inclusive) and the specified bound (exclusive).

default int nextInt()

Returns a pseudorandomly chosen int value.

default int nextInt(int bound)

Returns a pseudorandomly chosen int value between zero (inclusive) and the specified bound (exclusive).

default long nextLong(long origin, long bound)

Returns a pseudorandomly chosen long value between the specified origin (inclusive) and the specified bound (exclusive).

default long nextLong(long bound)

Returns a pseudorandomly chosen long value between zero (inclusive) and the specified bound (exclusive).

abstract long nextLong()

Returns a pseudorandomly chosen long value.

static RandomGenerator of(String name)

Returns an instance of RandomGenerator that utilizes the name algorithm.

Public methods

doubles

Added in API level 35
public DoubleStream doubles (long streamSize, 
                double randomNumberOrigin, 
                double randomNumberBound)

Returns a stream producing the given streamSize number of pseudorandomly chosen double values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextDouble(randomNumberOrigin, randomNumberBound).
Parameters
streamSize long: the number of values to generate

randomNumberOrigin double: the least value that can be produced

randomNumberBound double: the upper bound (exclusive) for each value produced

Returns
DoubleStream a stream of pseudorandomly chosen double values, each between the specified origin (inclusive) and the specified bound (exclusive)

Throws
IllegalArgumentException if streamSize is less than zero, or randomNumberOrigin is not finite, or randomNumberBound is not finite, or randomNumberOrigin is greater than or equal to randomNumberBound

doubles

Added in API level 35
public DoubleStream doubles (long streamSize)

Returns a stream producing the given streamSize number of pseudorandomly chosen double values.

Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextDouble().
Parameters
streamSize long: the number of values to generate

Returns
DoubleStream a stream of pseudorandomly chosen double values

Throws
IllegalArgumentException if streamSize is less than zero

doubles

Added in API level 35
public DoubleStream doubles ()

Returns an effectively unlimited stream of pseudorandomly chosen double values.

Implementation Note:
Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextDouble().
Returns
DoubleStream a stream of pseudorandomly chosen double values

doubles

Added in API level 35
public DoubleStream doubles (double randomNumberOrigin, 
                double randomNumberBound)

Returns an effectively unlimited stream of pseudorandomly chosen double values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Note:
  • It is permitted to implement this method in a manner equivalent to doubles (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextDouble(randomNumberOrigin, randomNumberBound).
Parameters
randomNumberOrigin double: the least value that can be produced

randomNumberBound double: the upper bound (exclusive) for each value produced

Returns
DoubleStream a stream of pseudorandomly chosen double values, each between the specified origin (inclusive) and the specified bound (exclusive)

Throws
IllegalArgumentException if randomNumberOrigin is not finite, or randomNumberBound is not finite, or randomNumberOrigin is greater than or equal to randomNumberBound

getDefault

Added in API level 35
public static RandomGenerator getDefault ()

Returns a RandomGenerator meeting the minimal requirement of having an algorithm whose state bits are greater than or equal 64.

Implementation Requirements:
  • Since algorithms will improve over time, there is no guarantee that this method will return the same algorithm over time.

    The default implementation selects L32X64MixRandom.

Returns
RandomGenerator a RandomGenerator

ints

Added in API level 35
public IntStream ints (long streamSize)

Returns a stream producing the given streamSize number of pseudorandomly chosen int values.

Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextInt().
Parameters
streamSize long: the number of values to generate

Returns
IntStream a stream of pseudorandomly chosen int values

Throws
IllegalArgumentException if streamSize is less than zero

ints

Added in API level 35
public IntStream ints (int randomNumberOrigin, 
                int randomNumberBound)

Returns an effectively unlimited stream of pseudorandomly chosen int values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Note:
  • It is permitted to implement this method in a manner equivalent to ints (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextInt(randomNumberOrigin, randomNumberBound).
Parameters
randomNumberOrigin int: the least value that can be produced

randomNumberBound int: the upper bound (exclusive) for each value produced

Returns
IntStream a stream of pseudorandomly chosen int values, each between the specified origin (inclusive) and the specified bound (exclusive)

Throws
IllegalArgumentException if randomNumberOrigin is greater than or equal to randomNumberBound

ints

Added in API level 35
public IntStream ints ()

Returns an effectively unlimited stream of pseudorandomly chosen int values.

Implementation Note:
Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextInt().
Returns
IntStream a stream of pseudorandomly chosen int values

ints

Added in API level 35
public IntStream ints (long streamSize, 
                int randomNumberOrigin, 
                int randomNumberBound)

Returns a stream producing the given streamSize number of pseudorandomly chosen int values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextInt(randomNumberOrigin, randomNumberBound).
Parameters
streamSize long: the number of values to generate

randomNumberOrigin int: the least value that can be produced

randomNumberBound int: the upper bound (exclusive) for each value produced

Returns
IntStream a stream of pseudorandomly chosen int values, each between the specified origin (inclusive) and the specified bound (exclusive)

Throws
IllegalArgumentException if streamSize is less than zero, or randomNumberOrigin is greater than or equal to randomNumberBound

isDeprecated

Added in API level 35
public boolean isDeprecated ()

Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.

Implementation Note:
  • Random number generator algorithms evolve over time; new algorithms will be introduced and old algorithms will lose standing. If an older algorithm is deemed unsuitable for continued use, it will be marked as deprecated to indicate that it may be removed at some point in the future.
Implementation Requirements:
  • The default implementation checks for the @Deprecated annotation.
Returns
boolean true if the implementation of RandomGenerator (algorithm) has been marked for deprecation

longs

Added in API level 35
public LongStream longs (long streamSize)

Returns a stream producing the given streamSize number of pseudorandomly chosen long values.

Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextLong().
Parameters
streamSize long: the number of values to generate

Returns
LongStream a stream of pseudorandomly chosen long values

Throws
IllegalArgumentException if streamSize is less than zero

longs

Added in API level 35
public LongStream longs ()

Returns an effectively unlimited stream of pseudorandomly chosen long values.

Implementation Note:
Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextLong().
Returns
LongStream a stream of pseudorandomly chosen long values

longs

Added in API level 35
public LongStream longs (long randomNumberOrigin, 
                long randomNumberBound)

Returns an effectively unlimited stream of pseudorandomly chosen long values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Note:
  • It is permitted to implement this method in a manner equivalent to longs (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextLong(randomNumberOrigin, randomNumberBound).
Parameters
randomNumberOrigin long: the least value that can be produced

randomNumberBound long: the upper bound (exclusive) for each value produced

Returns
LongStream a stream of pseudorandomly chosen long values, each between the specified origin (inclusive) and the specified bound (exclusive)

Throws
IllegalArgumentException if randomNumberOrigin is greater than or equal to randomNumberBound

longs

Added in API level 35
public LongStream longs (long streamSize, 
                long randomNumberOrigin, 
                long randomNumberBound)

Returns a stream producing the given streamSize number of pseudorandomly chosen long values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation produces a sequential stream that repeatedly calls nextLong(randomNumberOrigin, randomNumberBound).
Parameters
streamSize long: the number of values to generate

randomNumberOrigin long: the least value that can be produced

randomNumberBound long: the upper bound (exclusive) for each value produced

Returns
LongStream a stream of pseudorandomly chosen long values, each between the specified origin (inclusive) and the specified bound (exclusive)

Throws
IllegalArgumentException if streamSize is less than zero, or randomNumberOrigin is greater than or equal to randomNumberBound

nextBoolean

Added in API level 35
public boolean nextBoolean ()

Returns a pseudorandomly chosen boolean value.

The default implementation tests the high-order bit (sign bit) of a value produced by nextInt(), on the grounds that some algorithms for pseudorandom number generation produce values whose high-order bits have better statistical quality than the low-order bits.

Implementation Requirements:
  • The default implementation produces a result based on the sign bit of a number generated by nextInt().
Returns
boolean a pseudorandomly chosen boolean value

nextBytes

Added in API level 35
public void nextBytes (byte[] bytes)

Fills a user-supplied byte array with generated byte values pseudorandomly chosen uniformly from the range of values between -128 (inclusive) and 127 (inclusive).

Implementation Note:
  • Algorithm used to fill the byte array;
    void nextBytes(byte[] bytes) {
                   int i = 0;
                   int len = bytes.length;
                   for (int words = len >> 3; words--> 0; ) {
                       long rnd = nextLong();
                       for (int n = 8; n--> 0; rnd >>>= Byte.SIZE)
                           bytes[i++] = (byte)rnd;
                   }
                   if (i < len)
                       for (long rnd = nextLong(); i < len; rnd >>>= Byte.SIZE)
                           bytes[i++] = (byte)rnd;
               }
Implementation Requirements:
  • The default implementation produces results from repeated calls to nextLong().
Parameters
bytes byte: the byte array to fill with pseudorandom bytes

Throws
NullPointerException if bytes is null

nextDouble

Added in API level 35
public double nextDouble ()

Returns a pseudorandom double value between zero (inclusive) and one (exclusive).

Implementation Requirements:
  • The default implementation uses the 53 high-order bits from a call to nextLong().
Returns
double a pseudorandom double value between zero (inclusive) and one (exclusive)

nextDouble

Added in API level 35
public double nextDouble (double bound)

Returns a pseudorandomly chosen double value between zero (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that bound is a positive finite double. Then invokes nextDouble(), scaling the result so that the final result lies between 0.0 (inclusive) and bound (exclusive).
Parameters
bound double: the upper bound (exclusive) for the returned value. Must be positive and finite

Returns
double a pseudorandomly chosen double value between zero (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if bound is not both positive and finite

nextDouble

Added in API level 35
public double nextDouble (double origin, 
                double bound)

Returns a pseudorandomly chosen double value between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that origin and bound are positive finite doubles. Then calls nextDouble(), scaling and translating the result so that the final result lies between origin (inclusive) and bound (exclusive).
Parameters
origin double: the least value that can be returned

bound double: the upper bound (exclusive) for the returned value

Returns
double a pseudorandomly chosen double value between the origin (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if origin is not finite, or bound is not finite, or origin is greater than or equal to bound

nextExponential

Added in API level 35
public double nextExponential ()

Returns a nonnegative double value pseudorandomly chosen from an exponential distribution whose mean is 1.

Implementation Requirements:
  • The default implementation uses McFarland's fast modified ziggurat algorithm (largely table-driven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
Returns
double a nonnegative double value pseudorandomly chosen from an exponential distribution

nextFloat

Added in API level 35
public float nextFloat (float origin, 
                float bound)

Returns a pseudorandomly chosen float value between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that origin and bound are positive finite floats. Then invokes nextFloat(), scaling and translating the result so that the final result lies between origin (inclusive) and bound (exclusive).
Parameters
origin float: the least value that can be returned

bound float: the upper bound (exclusive)

Returns
float a pseudorandomly chosen float value between the origin (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if origin is not finite, or bound is not finite, or origin is greater than or equal to bound

nextFloat

Added in API level 35
public float nextFloat ()

Returns a pseudorandom float value between zero (inclusive) and one (exclusive).

Implementation Requirements:
  • The default implementation uses the 24 high-order bits from a call to nextInt().
Returns
float a pseudorandom float value between zero (inclusive) and one (exclusive)

nextFloat

Added in API level 35
public float nextFloat (float bound)

Returns a pseudorandomly chosen float value between zero (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that bound is a positive finite float. Then invokes nextFloat(), scaling the result so that the final result lies between 0.0f (inclusive) and bound (exclusive).
Parameters
bound float: the upper bound (exclusive) for the returned value. Must be positive and finite

Returns
float a pseudorandomly chosen float value between zero (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if bound is not both positive and finite

nextGaussian

Added in API level 35
public double nextGaussian (double mean, 
                double stddev)

Returns a double value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.

Implementation Requirements:
  • The default implementation uses McFarland's fast modified ziggurat algorithm (largely table-driven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
Parameters
mean double: the mean of the Gaussian distribution to be drawn from

stddev double: the standard deviation (square root of the variance) of the Gaussian distribution to be drawn from

Returns
double a double value pseudorandomly chosen from the specified Gaussian distribution

Throws
IllegalArgumentException if stddev is negative

nextGaussian

Added in API level 35
public double nextGaussian ()

Returns a double value pseudorandomly chosen from a Gaussian (normal) distribution whose mean is 0 and whose standard deviation is 1.

Implementation Requirements:
  • The default implementation uses McFarland's fast modified ziggurat algorithm (largely table-driven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
Returns
double a double value pseudorandomly chosen from a Gaussian distribution

nextInt

Added in API level 35
public int nextInt (int origin, 
                int bound)

Returns a pseudorandomly chosen int value between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that origin and bound are positive ints. Then invokes nextInt(), limiting the result to be greater that or equal origin and less than bound. If bound is a power of two then limiting is a simple masking operation. Otherwise, the result is re-calculated by invoking nextInt() until the result is greater than or equal origin and less than bound.
Parameters
origin int: the least value that can be returned

bound int: the upper bound (exclusive) for the returned value

Returns
int a pseudorandomly chosen int value between the origin (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if origin is greater than or equal to bound

nextInt

Added in API level 35
public int nextInt ()

Returns a pseudorandomly chosen int value.

Implementation Requirements:
  • The default implementation uses the 32 high-order bits from a call to nextLong().
Returns
int a pseudorandomly chosen int value

nextInt

Added in API level 35
public int nextInt (int bound)

Returns a pseudorandomly chosen int value between zero (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that bound is a positive int. Then invokes nextInt(), limiting the result to be greater than or equal zero and less than bound. If bound is a power of two then limiting is a simple masking operation. Otherwise, the result is re-calculated by invoking nextInt() until the result is greater than or equal zero and less than bound.
Parameters
bound int: the upper bound (exclusive) for the returned value. Must be positive.

Returns
int a pseudorandomly chosen int value between zero (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if bound is not positive

nextLong

Added in API level 35
public long nextLong (long origin, 
                long bound)

Returns a pseudorandomly chosen long value between the specified origin (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that origin and bound are positive longs. Then invokes nextLong(), limiting the result to be greater than or equal origin and less than bound. If bound is a power of two then limiting is a simple masking operation. Otherwise, the result is re-calculated by invoking nextLong() until the result is greater than or equal origin and less than bound.
Parameters
origin long: the least value that can be returned

bound long: the upper bound (exclusive) for the returned value

Returns
long a pseudorandomly chosen long value between the origin (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if origin is greater than or equal to bound

nextLong

Added in API level 35
public long nextLong (long bound)

Returns a pseudorandomly chosen long value between zero (inclusive) and the specified bound (exclusive).

Implementation Requirements:
  • The default implementation checks that bound is a positive long. Then invokes nextLong(), limiting the result to be greater than or equal zero and less than bound. If bound is a power of two then limiting is a simple masking operation. Otherwise, the result is re-calculated by invoking nextLong() until the result is greater than or equal zero and less than bound.
Parameters
bound long: the upper bound (exclusive) for the returned value. Must be positive.

Returns
long a pseudorandomly chosen long value between zero (inclusive) and the bound (exclusive)

Throws
IllegalArgumentException if bound is not positive

nextLong

Added in API level 35
public abstract long nextLong ()

Returns a pseudorandomly chosen long value.

Returns
long a pseudorandomly chosen long value

of

Added in API level 35
public static RandomGenerator of (String name)

Returns an instance of RandomGenerator that utilizes the name algorithm.

Parameters
name String: Name of random number generator algorithm

Returns
RandomGenerator An instance of RandomGenerator

Throws
NullPointerException if name is null
IllegalArgumentException if the named algorithm is not found