Summary: Nested Classes | Methods

RandomGenerator

public interface RandomGenerator

java.util.random.RandomGenerator

Known indirect subclasses

Random, RandomGenerator.ArbitrarilyJumpableGenerator, RandomGenerator.JumpableGenerator, RandomGenerator.LeapableGenerator, RandomGenerator.SplittableGenerator, RandomGenerator.StreamableGenerator, SecureRandom, SplittableRandom, ThreadLocalRandom

Random	An instance of this class is used to generate a stream of pseudorandom numbers; its period is only 2⁴⁸.
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.
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.
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.
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).
RandomGenerator.StreamableGenerator	The `StreamableGenerator` interface augments the `RandomGenerator` interface to provide methods that return streams of `RandomGenerator` objects.
SecureRandom	This class provides a cryptographically strong random number generator (RNG).
SplittableRandom	A generator of uniform pseudorandom values (with period 2⁶⁴) applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.
ThreadLocalRandom	A random number generator (with period 2⁶⁴) isolated to the current thread.

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 2^w 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 `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.

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

Parameters
`randomNumberOrigin`	`int`: the least value that can be produced
`randomNumberBound`	`int`: the upper bound (exclusive) for each value produced

Parameters
`randomNumberOrigin`	`long`: the least value that can be produced
`randomNumberBound`	`long`: the upper bound (exclusive) for each value produced

Parameters
`origin`	`double`: the least value that can be returned
`bound`	`double`: the upper bound (exclusive) for the returned value

Parameters
`origin`	`float`: the least value that can be returned
`bound`	`float`: the upper bound (exclusive)

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

Parameters
`origin`	`int`: the least value that can be returned
`bound`	`int`: the upper bound (exclusive) for the returned value

Parameters
`origin`	`long`: the least value that can be returned
`bound`	`long`: the upper bound (exclusive) for the returned value

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

RandomGenerator

Summary

Nested classes

Public methods

Public methods

doubles

Implementation Requirements:

doubles

Implementation Requirements:

doubles

Implementation Note:

Implementation Requirements:

doubles

Implementation Note:

Implementation Requirements:

getDefault

Implementation Requirements:

ints

Implementation Requirements:

ints

Implementation Note:

Implementation Requirements:

ints

Implementation Note:

Implementation Requirements:

ints

Implementation Requirements:

isDeprecated

Implementation Note:

Implementation Requirements:

longs

Implementation Requirements:

longs

Implementation Note:

Implementation Requirements:

longs

Implementation Note:

Implementation Requirements:

longs

Implementation Requirements:

nextBoolean

Implementation Requirements:

nextBytes

Implementation Note:

Implementation Requirements:

nextDouble

Implementation Requirements:

nextDouble

Implementation Requirements:

nextDouble

Implementation Requirements:

nextExponential

Implementation Requirements:

nextFloat

Implementation Requirements:

nextFloat

Implementation Requirements:

nextFloat

Implementation Requirements:

nextGaussian

Implementation Requirements:

nextGaussian

Implementation Requirements:

nextInt

Implementation Requirements:

nextInt

Implementation Requirements:

nextInt

Implementation Requirements:

nextLong

Implementation Requirements:

nextLong

Implementation Requirements:

nextLong

of