Added in API level 1

Random

open class Random : RandomGenerator, Serializable

kotlin.Any
↳	java.util.Random

Known Direct Subclasses

SecureRandom, ThreadLocalRandom

SecureRandom	This class provides a cryptographically strong random number generator (RNG).
ThreadLocalRandom	A random number generator (with period 264) isolated to the current thread.

An instance of this class is used to generate a stream of pseudorandom numbers; its period is only 248. The class uses a 48-bit seed, which is modified using a linear congruential formula. (See Donald E. Knuth, The Art of Computer Programming, Volume 2, Third edition: Seminumerical Algorithms, Section 3.2.1.)

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers. In order to guarantee this property, particular algorithms are specified for the class Random. Java implementations must use all the algorithms shown here for the class Random, for the sake of absolute portability of Java code. However, subclasses of class Random are permitted to use other algorithms, so long as they adhere to the general contracts for all the methods.

The algorithms implemented by class Random use a protected utility method that on each invocation can supply up to 32 pseudorandomly generated bits.

Many applications will find the method Math.random simpler to use.

Instances of java.util.Random are threadsafe. However, the concurrent use of the same java.util.Random instance across threads may encounter contention and consequent poor performance. Consider instead using java.util.concurrent.ThreadLocalRandom in multithreaded designs.

Instances of java.util.Random are not cryptographically secure. Consider instead using java.security.SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.

Summary

Public constructors
`Random()` Creates a new random number generator.
`Random(seed: Long)` Creates a new random number generator using a single `long` seed.

Public methods
open DoubleStream!	`doubles()` Returns an effectively unlimited stream of pseudorandom `double` values, each between zero (inclusive) and one (exclusive).
open DoubleStream!	`doubles(randomNumberOrigin: Double, randomNumberBound: Double)` Returns an effectively unlimited stream of pseudorandom `double` values, each conforming to the given origin (inclusive) and bound (exclusive).
open DoubleStream!	`doubles(streamSize: Long)` Returns a stream producing the given `streamSize` number of pseudorandom `double` values, each between zero (inclusive) and one (exclusive).
open DoubleStream!	`doubles(streamSize: Long, randomNumberOrigin: Double, randomNumberBound: Double)` Returns a stream producing the given `streamSize` number of pseudorandom `double` values, each conforming to the given origin (inclusive) and bound (exclusive).
open static Random!	`from(generator: RandomGenerator!)` Returns an instance of `Random` that delegates method calls to the `RandomGenerator` argument.
open IntStream!	`ints()` Returns an effectively unlimited stream of pseudorandom `int` values.
open IntStream!	`ints(randomNumberOrigin: Int, randomNumberBound: Int)` Returns an effectively unlimited stream of pseudorandom `int` values, each conforming to the given origin (inclusive) and bound (exclusive).
open IntStream!	`ints(streamSize: Long)` Returns a stream producing the given `streamSize` number of pseudorandom `int` values.
open IntStream!	`ints(streamSize: Long, randomNumberOrigin: Int, randomNumberBound: Int)` Returns a stream producing the given `streamSize` number of pseudorandom `int` values, each conforming to the given origin (inclusive) and bound (exclusive).
open LongStream!	`longs()` Returns an effectively unlimited stream of pseudorandom `long` values.
open LongStream!	`longs(streamSize: Long)` Returns a stream producing the given `streamSize` number of pseudorandom `long` values.
open LongStream!	`longs(randomNumberOrigin: Long, randomNumberBound: Long)` Returns an effectively unlimited stream of pseudorandom `long` values, each conforming to the given origin (inclusive) and bound (exclusive).
open LongStream!	`longs(streamSize: Long, randomNumberOrigin: Long, randomNumberBound: Long)` Returns a stream producing the given `streamSize` number of pseudorandom `long`, each conforming to the given origin (inclusive) and bound (exclusive).
open Boolean	`nextBoolean()` Returns the next pseudorandom, uniformly distributed `boolean` value from this random number generator's sequence.
open Unit	`nextBytes(bytes: ByteArray!)` Generates random bytes and places them into a user-supplied byte array.
open Double	`nextDouble()` Returns the next pseudorandom, uniformly distributed `double` value between `0.0` and `1.0` from this random number generator's sequence.
open Float	`nextFloat()` Returns the next pseudorandom, uniformly distributed `float` value between `0.0` and `1.0` from this random number generator's sequence.
open Double	`nextGaussian()` Returns the next pseudorandom, Gaussian ("normally") distributed `double` value with mean `0.0` and standard deviation `1.0` from this random number generator's sequence.
open Int	`nextInt()` Returns the next pseudorandom, uniformly distributed `int` value from this random number generator's sequence.
open Int	`nextInt(bound: Int)` Returns a pseudorandom, uniformly distributed `int` value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.
open Long	`nextLong()` Returns the next pseudorandom, uniformly distributed `long` value from this random number generator's sequence.
open Unit	`setSeed(seed: Long)` Sets or updates the seed of this random number generator using the provided `long` seed value (optional operation).

Protected methods
open Int	`next(bits: Int)` Generates the next pseudorandom number.

Inherited functions

From class RandomGenerator

`DoubleStream!`	`equiDoubles(left: Double, right: Double, isLeftIncluded: Boolean, isRightIncluded: Boolean)` Returns an effectively unlimited stream of pseudorandomly chosen `double` values, where each value is between the specified `left` boundary and the specified `right` boundary. The `left` boundary is included as indicated by `isLeftIncluded`; similarly, the `right` boundary is included as indicated by `isRightIncluded`. 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 the `double`s produced by the stream depends on the quality of the underlying `nextLong(long)`.
`Boolean`	`isDeprecated()` Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.
`Double`	`nextDouble(bound: Double)` Returns a pseudorandomly chosen `double` value between zero (inclusive) and the specified bound (exclusive).
`Double`	`nextDouble(origin: Double, bound: Double)` Returns a pseudorandomly chosen `double` value between the specified origin (inclusive) and the specified bound (exclusive).
`Double`	`nextExponential()` Returns a nonnegative `double` value pseudorandomly chosen from an exponential distribution whose mean is 1.
`Float`	`nextFloat(bound: Float)` Returns a pseudorandomly chosen `float` value between zero (inclusive) and the specified bound (exclusive).
`Float`	`nextFloat(origin: Float, bound: Float)` Returns a pseudorandomly chosen `float` value between the specified origin (inclusive) and the specified bound (exclusive).
`Double`	`nextGaussian(mean: Double, stddev: Double)` Returns a `double` value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.
`Int`	`nextInt(origin: Int, bound: Int)` Returns a pseudorandomly chosen `int` value between the specified origin (inclusive) and the specified bound (exclusive).
`Long`	`nextLong(bound: Long)` Returns a pseudorandomly chosen `long` value between zero (inclusive) and the specified bound (exclusive).
`Long`	`nextLong(origin: Long, bound: Long)` Returns a pseudorandomly chosen `long` value between the specified origin (inclusive) and the specified bound (exclusive).

Public constructors

Random

Added in API level 1

Random()

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

Random

Added in API level 1

Random(seed: Long)

Creates a new random number generator using a single long seed. The seed is the initial value of the internal state of the pseudorandom number generator which is maintained by method next.

Parameters
`seed`	Long: the initial seed

See Also

#setSeed(long)

Public methods

doubles

Added in API level 24

open fun doubles(): DoubleStream!

Returns an effectively unlimited stream of pseudorandom double values, each between zero (inclusive) and one (exclusive).

A pseudorandom double value is generated as if it's the result of calling the method nextDouble().

Return
`DoubleStream!`	a stream of pseudorandom `double` values

doubles

Added in API level 24

open fun doubles(
    randomNumberOrigin: Double, 
    randomNumberBound: Double
): DoubleStream!

Returns an effectively unlimited stream of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).

Parameters
`randomNumberOrigin`	Double: the origin (inclusive) of each random value
`randomNumberBound`	Double: the bound (exclusive) of each random value

Return
`DoubleStream!`	a stream of pseudorandom `double` values, each with the given origin (inclusive) and bound (exclusive)

Exceptions
`java.lang.IllegalArgumentException`	if `randomNumberOrigin` is not finite, or `randomNumberBound` is not finite, or `randomNumberOrigin` is greater than or equal to `randomNumberBound`

doubles

Added in API level 24

open fun doubles(streamSize: Long): DoubleStream!

Returns a stream producing the given streamSize number of pseudorandom double values, each between zero (inclusive) and one (exclusive).

A pseudorandom double value is generated as if it's the result of calling the method nextDouble().

Parameters
`streamSize`	Long: the number of values to generate

Return
`DoubleStream!`	a stream of `double` values

Exceptions
`java.lang.IllegalArgumentException`	if `streamSize` is less than zero

doubles

Added in API level 24

open fun doubles(
    streamSize: Long, 
    randomNumberOrigin: Double, 
    randomNumberBound: Double
): DoubleStream!

Returns a stream producing the given streamSize number of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).

Parameters
`streamSize`	Long: the number of values to generate
`randomNumberOrigin`	Double: the origin (inclusive) of each random value
`randomNumberBound`	Double: the bound (exclusive) of each random value

Return
`DoubleStream!`	a stream of pseudorandom `double` values, each with the given origin (inclusive) and bound (exclusive)

Exceptions
`java.lang.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`