 All Known Subinterfaces:
RandomGenerator.ArbitrarilyJumpableGenerator
,RandomGenerator.JumpableGenerator
,RandomGenerator.LeapableGenerator
,RandomGenerator.SplittableGenerator
,RandomGenerator.StreamableGenerator
 All Known Implementing Classes:
Random
,SecureRandom
,SplittableRandom
,ThreadLocalRandom
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
2^{w} values between 0.0 (inclusive) and 1.0 (exclusive),
where w is Float.PRECISION
for float
values
and Double.PRECISION
for double
values, such that adjacent values differ by 2^{−w}
(notice that this set is a subset of the set of
all representable floatingpoint 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 threadsafe. It is recommended that multithreaded applications
use either ThreadLocalRandom
or (preferably) pseudorandom number
generators that implement the RandomGenerator.SplittableGenerator
or
RandomGenerator.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
securitysensitive 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.
 Since:
 17

Nested Class Summary
Modifier and TypeInterfaceDescriptionstatic interface
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.static interface
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. 2^{64}) to a distant point in the state cycle.static interface
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. 2^{128}), to a very distant point in the state cycle.static interface
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).static interface
TheRandomGenerator.StreamableGenerator
interface augments theRandomGenerator
interface to provide methods that return streams ofRandomGenerator
objects. 
Method Summary
Modifier and TypeMethodDescriptiondefault DoubleStream
doubles()
Returns an effectively unlimited stream of pseudorandomly chosendouble
values.default DoubleStream
doubles
(double randomNumberOrigin, double randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosendouble
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 givenstreamSize
number of pseudorandomly chosendouble
values.default DoubleStream
doubles
(long streamSize, double randomNumberOrigin, double randomNumberBound) Returns a stream producing the givenstreamSize
number of pseudorandomly chosendouble
values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).default DoubleStream
equiDoubles
(double left, double right, boolean isLeftIncluded, boolean isRightIncluded) Returns an effectively unlimited stream of pseudorandomly chosendouble
values, where each value is between the specifiedleft
boundary and the specifiedright
boundary.static RandomGenerator
Returns aRandomGenerator
meeting the minimal requirement of having an algorithm whose state bits are greater than or equal 64.default IntStream
ints()
Returns an effectively unlimited stream of pseudorandomly chosenint
values.default IntStream
ints
(int randomNumberOrigin, int randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosenint
values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).default IntStream
ints
(long streamSize) Returns a stream producing the givenstreamSize
number of pseudorandomly chosenint
values.default IntStream
ints
(long streamSize, int randomNumberOrigin, int randomNumberBound) Returns a stream producing the givenstreamSize
number of pseudorandomly chosenint
values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).default boolean
Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.default LongStream
longs()
Returns an effectively unlimited stream of pseudorandomly chosenlong
values.default LongStream
longs
(long streamSize) Returns a stream producing the givenstreamSize
number of pseudorandomly chosenlong
values.default LongStream
longs
(long randomNumberOrigin, long randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosenlong
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 givenstreamSize
number of pseudorandomly chosenlong
values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).default boolean
Returns a pseudorandomly chosenboolean
value.default void
nextBytes
(byte[] bytes) Fills a usersupplied byte array with generated byte values pseudorandomly chosen uniformly from the range of values between 128 (inclusive) and 127 (inclusive).default double
Returns a pseudorandomdouble
value between zero (inclusive) and one (exclusive).default double
nextDouble
(double bound) Returns a pseudorandomly chosendouble
value between zero (inclusive) and the specified bound (exclusive).default double
nextDouble
(double origin, double bound) Returns a pseudorandomly chosendouble
value between the specified origin (inclusive) and the specified bound (exclusive).default double
Returns a nonnegativedouble
value pseudorandomly chosen from an exponential distribution whose mean is 1.default float
Returns a pseudorandomfloat
value between zero (inclusive) and one (exclusive).default float
nextFloat
(float bound) Returns a pseudorandomly chosenfloat
value between zero (inclusive) and the specified bound (exclusive).default float
nextFloat
(float origin, float bound) Returns a pseudorandomly chosenfloat
value between the specified origin (inclusive) and the specified bound (exclusive).default double
Returns adouble
value pseudorandomly chosen from a Gaussian (normal) distribution whose mean is 0 and whose standard deviation is 1.default double
nextGaussian
(double mean, double stddev) Returns adouble
value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.default int
nextInt()
Returns a pseudorandomly chosenint
value.default int
nextInt
(int bound) Returns a pseudorandomly chosenint
value between zero (inclusive) and the specified bound (exclusive).default int
nextInt
(int origin, int bound) Returns a pseudorandomly chosenint
value between the specified origin (inclusive) and the specified bound (exclusive).long
nextLong()
Returns a pseudorandomly chosenlong
value.default long
nextLong
(long bound) Returns a pseudorandomly chosenlong
value between zero (inclusive) and the specified bound (exclusive).default long
nextLong
(long origin, long bound) Returns a pseudorandomly chosenlong
value between the specified origin (inclusive) and the specified bound (exclusive).static RandomGenerator

Method Details

of
 Parameters:
name
 Name of random number generator algorithm Returns:
 An instance of
RandomGenerator
 Throws:
NullPointerException
 if name is nullIllegalArgumentException
 if the named algorithm is not found

getDefault
Returns aRandomGenerator
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:
 a
RandomGenerator

isDeprecated
default boolean isDeprecated()Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation. Implementation Requirements:
 The default implementation checks for the @Deprecated annotation.
 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.
 Returns:
 true if the implementation of RandomGenerator (algorithm) has been marked for deprecation

doubles
Returns an effectively unlimited stream of pseudorandomly chosendouble
values. Implementation Requirements:
 The default implementation produces a sequential stream
that repeatedly calls
nextDouble
().  Implementation Note:
 It is permitted to implement this method in a manner equivalent to
doubles
(Long.MAX_VALUE
).  Returns:
 a stream of pseudorandomly chosen
double
values

doubles
Returns an effectively unlimited stream of pseudorandomly chosendouble
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).  Implementation Note:
 It is permitted to implement this method in a manner equivalent to
doubles
(Long.MAX_VALUE
, randomNumberOrigin, randomNumberBound).  Parameters:
randomNumberOrigin
 the least value that can be producedrandomNumberBound
 the upper bound (exclusive) for each value produced Returns:
 a stream of pseudorandomly chosen
double
values, each between the specified origin (inclusive) and the specified bound (exclusive)  Throws:
IllegalArgumentException
 ifrandomNumberOrigin
is not finite, orrandomNumberBound
is not finite, orrandomNumberOrigin
is greater than or equal torandomNumberBound

doubles
Returns a stream producing the givenstreamSize
number of pseudorandomly chosendouble
values. Implementation Requirements:
 The default implementation produces a sequential stream
that repeatedly calls
nextDouble()
.  Parameters:
streamSize
 the number of values to generate Returns:
 a stream of pseudorandomly chosen
double
values  Throws:
IllegalArgumentException
 ifstreamSize
is less than zero

doubles
Returns a stream producing the givenstreamSize
number of pseudorandomly chosendouble
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
 the number of values to generaterandomNumberOrigin
 the least value that can be producedrandomNumberBound
 the upper bound (exclusive) for each value produced Returns:
 a stream of pseudorandomly chosen
double
values, each between the specified origin (inclusive) and the specified bound (exclusive)  Throws:
IllegalArgumentException
 ifstreamSize
is less than zero, orrandomNumberOrigin
is not finite, orrandomNumberBound
is not finite, orrandomNumberOrigin
is greater than or equal torandomNumberBound

equiDoubles
default DoubleStream equiDoubles(double left, double right, boolean isLeftIncluded, boolean isRightIncluded) Returns an effectively unlimited stream of pseudorandomly chosendouble
values, where each value is between the specifiedleft
boundary and the specifiedright
boundary. Theleft
boundary is included as indicated byisLeftIncluded
; similarly, theright
boundary is included as indicated byisRightIncluded
.The stream potentially produces all multiples k δ (k integer) lying in the interval specified by the parameters, where δ > 0 is the smallest number for which all these multiples are exact
double
s. They are therefore all equidistant. The uniformity of the distribution of thedouble
s produced by the stream depends on the quality of the underlyingnextLong(long)
. Implementation Requirements:
 The default implementation first determines the δ above.
It then computes both the smallest integer k_{l}
such that k_{l} δ lies inside
the given interval, and the smallest integer n > 0 such that
(k_{l} + n) δ lies
outside the interval.
Finally, it returns a stream which generates the
double
s according to (k_{l} +nextLong(
n)
) δ. The stream never produces0.0
, although it may produce0.0
if the specified interval contains 0.  Parameters:
left
 the left boundaryright
 the right boundaryisLeftIncluded
 whether theleft
boundary is includedisRightIncluded
 whether theright
boundary is included Returns:
 a stream of pseudorandomly chosen
double
values, each betweenleft
andright
, as specified above.  Throws:
IllegalArgumentException
 ifleft
is not finite, orright
is not finite, or if the specified interval is empty. Since:
 22

ints
Returns an effectively unlimited stream of pseudorandomly chosenint
values. Implementation Requirements:
 The default implementation produces a sequential stream
that repeatedly calls
nextInt
().  Implementation Note:
 It is permitted to implement this method in a manner
equivalent to
ints
(Long.MAX_VALUE
).  Returns:
 a stream of pseudorandomly chosen
int
values

ints
Returns an effectively unlimited stream of pseudorandomly chosenint
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).  Implementation Note:
 It is permitted to implement this method in a manner equivalent to
ints
(Long.MAX_VALUE
, randomNumberOrigin, randomNumberBound).  Parameters:
randomNumberOrigin
 the least value that can be producedrandomNumberBound
 the upper bound (exclusive) for each value produced Returns:
 a stream of pseudorandomly chosen
int
values, each between the specified origin (inclusive) and the specified bound (exclusive)  Throws:
IllegalArgumentException
 ifrandomNumberOrigin
is greater than or equal torandomNumberBound

ints
Returns a stream producing the givenstreamSize
number of pseudorandomly chosenint
values. Implementation Requirements:
 The default implementation produces a sequential stream
that repeatedly calls
nextInt
().  Parameters:
streamSize
 the number of values to generate Returns:
 a stream of pseudorandomly chosen
int
values  Throws:
IllegalArgumentException
 ifstreamSize
is less than zero

ints
Returns a stream producing the givenstreamSize
number of pseudorandomly chosenint
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
 the number of values to generaterandomNumberOrigin
 the least value that can be producedrandomNumberBound
 the upper bound (exclusive) for each value produced Returns:
 a stream of pseudorandomly chosen
int
values, each between the specified origin (inclusive) and the specified bound (exclusive)  Throws:
IllegalArgumentException
 ifstreamSize
is less than zero, orrandomNumberOrigin
is greater than or equal torandomNumberBound

longs
Returns an effectively unlimited stream of pseudorandomly chosenlong
values. Implementation Requirements:
 The default implementation produces a sequential stream
that repeatedly calls
nextLong
().  Implementation Note:
 It is permitted to implement this method in a manner
equivalent to
longs
(Long.MAX_VALUE
).  Returns:
 a stream of pseudorandomly chosen
long
values

longs
Returns an effectively unlimited stream of pseudorandomly chosenlong
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).  Implementation Note:
 It is permitted to implement this method in a manner equivalent to
longs
(Long.MAX_VALUE
, randomNumberOrigin, randomNumberBound).  Parameters:
randomNumberOrigin
 the least value that can be producedrandomNumberBound
 the upper bound (exclusive) for each value produced Returns:
 a stream of pseudorandomly chosen
long
values, each between the specified origin (inclusive) and the specified bound (exclusive)  Throws:
IllegalArgumentException
 ifrandomNumberOrigin
is greater than or equal torandomNumberBound

longs
Returns a stream producing the givenstreamSize
number of pseudorandomly chosenlong
values. Implementation Requirements:
 The default implementation produces a sequential stream
that repeatedly calls
nextLong
().  Parameters:
streamSize
 the number of values to generate Returns:
 a stream of pseudorandomly chosen
long
values  Throws:
IllegalArgumentException
 ifstreamSize
is less than zero

longs
Returns a stream producing the givenstreamSize
number of pseudorandomly chosenlong
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
 the number of values to generaterandomNumberOrigin
 the least value that can be producedrandomNumberBound
 the upper bound (exclusive) for each value produced Returns:
 a stream of pseudorandomly chosen
long
values, each between the specified origin (inclusive) and the specified bound (exclusive)  Throws:
IllegalArgumentException
 ifstreamSize
is less than zero, orrandomNumberOrigin
is greater than or equal torandomNumberBound

nextBoolean
default boolean nextBoolean()Returns a pseudorandomly chosenboolean
value.The default implementation tests the highorder bit (sign bit) of a value produced by
nextInt
(), on the grounds that some algorithms for pseudorandom number generation produce values whose highorder bits have better statistical quality than the loworder bits. Implementation Requirements:
 The default implementation produces a result based on the
sign bit of a number generated by
nextInt()
.  Returns:
 a pseudorandomly chosen
boolean
value

nextBytes
default void nextBytes(byte[] bytes) Fills a usersupplied byte array with generated byte values pseudorandomly chosen uniformly from the range of values between 128 (inclusive) and 127 (inclusive). Implementation Requirements:
 The default implementation produces results from repeated calls
to
nextLong()
.  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; }
 Parameters:
bytes
 the byte array to fill with pseudorandom bytes Throws:
NullPointerException
 if bytes is null

nextFloat
default float nextFloat()Returns a pseudorandomfloat
value between zero (inclusive) and one (exclusive). Implementation Requirements:
 The default implementation uses the
Float.PRECISION
highorder bits from a call tonextInt()
.  Returns:
 a pseudorandom
float
value between zero (inclusive) and one (exclusive)

nextFloat
default float nextFloat(float bound) Returns a pseudorandomly chosenfloat
value between zero (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation checks that
bound
is a positive finite float. Then invokesnextFloat()
, scaling the result so that the final result lies between0.0f
(inclusive) andbound
(exclusive).  Parameters:
bound
 the upper bound (exclusive) for the returned value. Must be positive and finite Returns:
 a pseudorandomly chosen
float
value between zero (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 ifbound
is not both positive and finite

nextFloat
default float nextFloat(float origin, float bound) Returns a pseudorandomly chosenfloat
value between the specified origin (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation verifies that the
origin
andbound
are valid then invokesnextFloat()
scaling and translating the result to fit betweenorigin
andbound
(exclusive).  Parameters:
origin
 the least value that can be returnedbound
 the upper bound (exclusive) Returns:
 a pseudorandomly chosen
float
value between the origin (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 iforigin
is not finite, orbound
is not finite, ororigin
is greater than or equal tobound

nextDouble
default double nextDouble()Returns a pseudorandomdouble
value between zero (inclusive) and one (exclusive). Implementation Requirements:
 The default implementation uses the
Double.PRECISION
highorder bits from a call tonextLong()
.  Returns:
 a pseudorandom
double
value between zero (inclusive) and one (exclusive)

nextDouble
default double nextDouble(double bound) Returns a pseudorandomly chosendouble
value between zero (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation checks that
bound
is a positive finite double. Then invokesnextDouble()
, scaling the result so that the final result lies between0.0
(inclusive) andbound
(exclusive).  Parameters:
bound
 the upper bound (exclusive) for the returned value. Must be positive and finite Returns:
 a pseudorandomly chosen
double
value between zero (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 ifbound
is not both positive and finite

nextDouble
default double nextDouble(double origin, double bound) Returns a pseudorandomly chosendouble
value between the specified origin (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation verifies that the
origin
andbound
are valid, then invokesnextDouble()
scaling and translating the result to fit betweenorigin
andbound
( exclusive).  Parameters:
origin
 the least value that can be returnedbound
 the upper bound (exclusive) for the returned value Returns:
 a pseudorandomly chosen
double
value between the origin (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 iforigin
is not finite, orbound
is not finite, ororigin
is greater than or equal tobound

nextInt
default int nextInt()Returns a pseudorandomly chosenint
value. Implementation Requirements:
 The default implementation uses the 32 highorder bits from a call to
nextLong
().  Returns:
 a pseudorandomly chosen
int
value

nextInt
default int nextInt(int bound) Returns a pseudorandomly chosenint
value between zero (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation checks that
bound
is a positiveint
. Then invokesnextInt()
, limiting the result to be greater than or equal zero and less thanbound
. Ifbound
is a power of two then limiting is a simple masking operation. Otherwise, the result is recalculated by invokingnextInt()
until the result is greater than or equal zero and less thanbound
.  Parameters:
bound
 the upper bound (exclusive) for the returned value. Must be positive. Returns:
 a pseudorandomly chosen
int
value between zero (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 ifbound
is not positive

nextInt
default int nextInt(int origin, int bound) Returns a pseudorandomly chosenint
value between the specified origin (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation checks that
origin
andbound
are positiveints
. Then invokesnextInt()
, limiting the result to be greater that or equalorigin
and less thanbound
. Ifbound
is a power of two then limiting is a simple masking operation. Otherwise, the result is recalculated by invokingnextInt()
until the result is greater than or equalorigin
and less thanbound
.  Parameters:
origin
 the least value that can be returnedbound
 the upper bound (exclusive) for the returned value Returns:
 a pseudorandomly chosen
int
value between the origin (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 iforigin
is greater than or equal tobound

nextLong
long nextLong()Returns a pseudorandomly chosenlong
value. Returns:
 a pseudorandomly chosen
long
value

nextLong
default long nextLong(long bound) Returns a pseudorandomly chosenlong
value between zero (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation checks that
bound
is a positivelong
. Then invokesnextLong()
, limiting the result to be greater than or equal zero and less thanbound
. Ifbound
is a power of two then limiting is a simple masking operation. Otherwise, the result is recalculated by invokingnextLong()
until the result is greater than or equal zero and less thanbound
.  Parameters:
bound
 the upper bound (exclusive) for the returned value. Must be positive. Returns:
 a pseudorandomly chosen
long
value between zero (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 ifbound
is not positive

nextLong
default long nextLong(long origin, long bound) Returns a pseudorandomly chosenlong
value between the specified origin (inclusive) and the specified bound (exclusive). Implementation Requirements:
 The default implementation checks that
origin
andbound
are positivelongs
. Then invokesnextLong()
, limiting the result to be greater than or equalorigin
and less thanbound
. Ifbound
is a power of two then limiting is a simple masking operation. Otherwise, the result is recalculated by invokingnextLong()
until the result is greater than or equalorigin
and less thanbound
.  Parameters:
origin
 the least value that can be returnedbound
 the upper bound (exclusive) for the returned value Returns:
 a pseudorandomly chosen
long
value between the origin (inclusive) and the bound (exclusive)  Throws:
IllegalArgumentException
 iforigin
is greater than or equal tobound

nextGaussian
default double nextGaussian()Returns adouble
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 tabledriven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
 Returns:
 a
double
value pseudorandomly chosen from a Gaussian distribution

nextGaussian
default double nextGaussian(double mean, double stddev) Returns adouble
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 tabledriven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
 Parameters:
mean
 the mean of the Gaussian distribution to be drawn fromstddev
 the standard deviation (square root of the variance) of the Gaussian distribution to be drawn from Returns:
 a
double
value pseudorandomly chosen from the specified Gaussian distribution  Throws:
IllegalArgumentException
 ifstddev
is negative

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