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 2−w
(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 |
Public methods | |
---|---|
default
DoubleStream
|
doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
Returns a stream producing the given |
default
DoubleStream
|
doubles(long streamSize)
Returns a stream producing the given |
default
DoubleStream
|
doubles()
Returns an effectively unlimited stream of pseudorandomly chosen
|
default
DoubleStream
|
doubles(double randomNumberOrigin, double randomNumberBound)
Returns an effectively unlimited stream of pseudorandomly chosen
|
static
RandomGenerator
|
getDefault()
Returns a |
default
IntStream
|
ints(long streamSize)
Returns a stream producing the given |
default
IntStream
|
ints(int randomNumberOrigin, int randomNumberBound)
Returns an effectively unlimited stream of pseudorandomly chosen
|
default
IntStream
|
ints()
Returns an effectively unlimited stream of pseudorandomly chosen
|
default
IntStream
|
ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
Returns a stream producing the given |
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 |
default
LongStream
|
longs()
Returns an effectively unlimited stream of pseudorandomly chosen
|
default
LongStream
|
longs(long randomNumberOrigin, long randomNumberBound)
Returns an effectively unlimited stream of pseudorandomly chosen
|
default
LongStream
|
longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
Returns a stream producing the given |
default
boolean
|
nextBoolean()
Returns a pseudorandomly chosen |
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 |
default
double
|
nextDouble(double bound)
Returns a pseudorandomly chosen |
default
double
|
nextDouble(double origin, double bound)
Returns a pseudorandomly chosen |
default
double
|
nextExponential()
Returns a nonnegative |
default
float
|
nextFloat(float origin, float bound)
Returns a pseudorandomly chosen |
default
float
|
nextFloat()
Returns a pseudorandom |
default
float
|
nextFloat(float bound)
Returns a pseudorandomly chosen |
default
double
|
nextGaussian(double mean, double stddev)
Returns a |
default
double
|
nextGaussian()
Returns a |
default
int
|
nextInt(int origin, int bound)
Returns a pseudorandomly chosen |
default
int
|
nextInt()
Returns a pseudorandomly chosen |
default
int
|
nextInt(int bound)
Returns a pseudorandomly chosen |
default
long
|
nextLong(long origin, long bound)
Returns a pseudorandomly chosen |
default
long
|
nextLong(long bound)
Returns a pseudorandomly chosen |
abstract
long
|
nextLong()
Returns a pseudorandomly chosen |
static
RandomGenerator
|
of(String name)
Returns an instance of |
Public methods
doubles
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
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
public DoubleStream doubles ()
Returns an effectively unlimited stream of pseudorandomly chosen
double
values.
Implementation Note:
- It is permitted to implement this method in a manner equivalent to
doubles
(Long.MAX_VALUE
).
Implementation Requirements:
- The default implementation produces a sequential stream
that repeatedly calls
nextDouble
().
Returns | |
---|---|
DoubleStream |
a stream of pseudorandomly chosen double values |
doubles
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
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
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
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
public IntStream ints ()
Returns an effectively unlimited stream of pseudorandomly chosen
int
values.
Implementation Note:
- It is permitted to implement this method in a manner
equivalent to
ints
(Long.MAX_VALUE
).
Implementation Requirements:
- The default implementation produces a sequential stream
that repeatedly calls
nextInt
().
Returns | |
---|---|
IntStream |
a stream of pseudorandomly chosen int values |
ints
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
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
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
public LongStream longs ()
Returns an effectively unlimited stream of pseudorandomly chosen
long
values.
Implementation Note:
- It is permitted to implement this method in a manner
equivalent to
longs
(Long.MAX_VALUE
).
Implementation Requirements:
- The default implementation produces a sequential stream
that repeatedly calls
nextLong
().
Returns | |
---|---|
LongStream |
a stream of pseudorandomly chosen long values |
longs
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
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
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
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
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
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 invokesnextDouble()
, scaling the result so that the final result lies between0.0
(inclusive) andbound
(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
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
andbound
are positive finite doubles. Then callsnextDouble()
, scaling and translating the result so that the final result lies betweenorigin
(inclusive) andbound
(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
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
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
andbound
are positive finite floats. Then invokesnextFloat()
, scaling and translating the result so that the final result lies betweenorigin
(inclusive) andbound
(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
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
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 invokesnextFloat()
, scaling the result so that the final result lies between0.0f
(inclusive) andbound
(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
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
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
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
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 re-calculated by invokingnextInt()
until the result is greater than or equalorigin
and less thanbound
.
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
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
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 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 re-calculated by invokingnextInt()
until the result is greater than or equal zero and less thanbound
.
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
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
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 re-calculated by invokingnextLong()
until the result is greater than or equalorigin
and less thanbound
.
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
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 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 re-calculated by invokingnextLong()
until the result is greater than or equal zero and less thanbound
.
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
public abstract long nextLong ()
Returns a pseudorandomly chosen long
value.
Returns | |
---|---|
long |
a pseudorandomly chosen long value |
of
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 |
Content and code samples on this page are subject to the licenses described in the Content License. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
Last updated 2024-06-18 UTC.