# ThreadLocalRandom
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
# ThreadLocalRandom
```
class ThreadLocalRandom : Random
```
|---|---|----------------------------------------------------------------------------------------------------------------------------------|
| [kotlin.Any](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html) |||
| ↳ | [java.util.Random](https://developer.android.com/reference/kotlin/java/util/Random.html#) ||
| | ↳ | [java.util.concurrent.ThreadLocalRandom](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#) |
A random number generator (with period 264) isolated to the current thread. Like the global[java.util.Random](https://developer.android.com/reference/kotlin/java/util/Random.html#)generator used by the[java.lang.Math](https://developer.android.com/reference/kotlin/java/lang/Math.html#)class, a`ThreadLocalRandom`is initialized with an internally generated seed that may not otherwise be modified. When applicable, use of`ThreadLocalRandom`rather than shared`Random`objects in concurrent programs will typically encounter much less overhead and contention. Use of`ThreadLocalRandom`is particularly appropriate when multiple tasks (for example, each a[ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask)) use random numbers in parallel in thread pools.
Usages of this class should typically be of the form:`ThreadLocalRandom.current().nextX(...)`(where`X`is`Int`,`Long`, etc). When all usages are of this form, it is never possible to accidentally share a`ThreadLocalRandom`across multiple threads.
This class also provides additional commonly used bounded random generation methods.
Instances of`ThreadLocalRandom`are not cryptographically secure. Consider instead using[java.security.SecureRandom](https://developer.android.com/reference/kotlin/java/security/SecureRandom.html#)in security-sensitive applications. Additionally, default-constructed instances do not use a cryptographically random seed unless the java.lang.System#getProperty`java.util.secureRandomSeed`is set to`true`.
## Summary
| Public methods ||
|--------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| static[ThreadLocalRandom](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#)! | [current](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#current())`()` Returns the current thread's`ThreadLocalRandom`object. |
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | [doubles](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#doubles())`()` Returns an effectively unlimited stream of pseudorandom`double`values, each between zero (inclusive) and one (exclusive). |
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | [doubles](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#doubles(kotlin.Double,%20kotlin.Double))`(`randomNumberOrigin:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`, `randomNumberBound:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)` Returns an effectively unlimited stream of pseudorandom`double`values, each conforming to the given origin (inclusive) and bound (exclusive). |
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | [doubles](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#doubles(kotlin.Long))`(`streamSize:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns a stream producing the given`streamSize`number of pseudorandom`double`values, each between zero (inclusive) and one (exclusive). |
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | [doubles](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#doubles(kotlin.Long,%20kotlin.Double,%20kotlin.Double))`(`streamSize:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `randomNumberOrigin:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`, `randomNumberBound:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)` Returns a stream producing the given`streamSize`number of pseudorandom`double`values, each conforming to the given origin (inclusive) and bound (exclusive). |
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | [ints](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#ints())`()` Returns an effectively unlimited stream of pseudorandom`int`values. |
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | [ints](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#ints(kotlin.Int,%20kotlin.Int))`(`randomNumberOrigin:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`, `randomNumberBound:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` Returns an effectively unlimited stream of pseudorandom`int`values, each conforming to the given origin (inclusive) and bound (exclusive). |
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | [ints](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#ints(kotlin.Long))`(`streamSize:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns a stream producing the given`streamSize`number of pseudorandom`int`values. |
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | [ints](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#ints(kotlin.Long,%20kotlin.Int,%20kotlin.Int))`(`streamSize:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `randomNumberOrigin:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`, `randomNumberBound:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` Returns a stream producing the given`streamSize`number of pseudorandom`int`values, each conforming to the given origin (inclusive) and bound (exclusive). |
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | [longs](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#longs())`()` Returns an effectively unlimited stream of pseudorandom`long`values. |
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | [longs](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#longs(kotlin.Long))`(`streamSize:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns a stream producing the given`streamSize`number of pseudorandom`long`values. |
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | [longs](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#longs(kotlin.Long,%20kotlin.Long))`(`randomNumberOrigin:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `randomNumberBound:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns an effectively unlimited stream of pseudorandom`long`values, each conforming to the given origin (inclusive) and bound (exclusive). |
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | [longs](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#longs(kotlin.Long,%20kotlin.Long,%20kotlin.Long))`(`streamSize:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `randomNumberOrigin:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `randomNumberBound:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns a stream producing the given`streamSize`number of pseudorandom`long`, each conforming to the given origin (inclusive) and bound (exclusive). |
| [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html) | [nextBoolean](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextBoolean())`()` Returns the next pseudorandom, uniformly distributed`boolean`value from this random number generator's sequence. |
| [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextDouble](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextDouble())`()` Returns the next pseudorandom, uniformly distributed`double`value between`0.0`and`1.0`from this random number generator's sequence. |
| [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextDouble](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextDouble(kotlin.Double))`(`bound:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)` Returns a pseudorandomly chosen`double`value between zero (inclusive) and the specified bound (exclusive). |
| [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextDouble](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextDouble(kotlin.Double,%20kotlin.Double))`(`origin:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`, `bound:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)` Returns a pseudorandomly chosen`double`value between the specified origin (inclusive) and the specified bound (exclusive). |
| [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | [nextFloat](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextFloat())`()` Returns the next pseudorandom, uniformly distributed`float`value between`0.0`and`1.0`from this random number generator's sequence. |
| [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | [nextFloat](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextFloat(kotlin.Float))`(`bound:` `[Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html)`)` Returns a pseudorandomly chosen`float`value between zero (inclusive) and the specified bound (exclusive). |
| [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | [nextFloat](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextFloat(kotlin.Float,%20kotlin.Float))`(`origin:` `[Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html)`, `bound:` `[Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html)`)` Returns a pseudorandomly chosen`float`value between the specified origin (inclusive) and the specified bound (exclusive). |
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [nextInt](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextInt())`()` Returns the next pseudorandom, uniformly distributed`int`value from this random number generator's sequence. |
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [nextInt](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextInt(kotlin.Int))`(`bound:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` Returns a pseudorandom, uniformly distributed`int`value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. |
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [nextInt](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextInt(kotlin.Int,%20kotlin.Int))`(`origin:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`, `bound:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` Returns a pseudorandomly chosen`int`value between the specified origin (inclusive) and the specified bound (exclusive). |
| [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | [nextLong](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextLong())`()` Returns the next pseudorandom, uniformly distributed`long`value from this random number generator's sequence. |
| [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | [nextLong](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextLong(kotlin.Long))`(`bound:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns a pseudorandomly chosen`long`value between zero (inclusive) and the specified bound (exclusive). |
| [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | [nextLong](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#nextLong(kotlin.Long,%20kotlin.Long))`(`origin:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `bound:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Returns a pseudorandomly chosen`long`value between the specified origin (inclusive) and the specified bound (exclusive). |
| [Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html) | [setSeed](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#setSeed(kotlin.Long))`(`seed:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)` Throws`UnsupportedOperationException`. |
| Protected methods ||
|----------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [next](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#next(kotlin.Int))`(`bits:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` Generates a pseudorandom number with the indicated number of low-order bits. |
| Inherited functions ||
|---|---|
| From class[Random](https://developer.android.com/reference/kotlin/java/util/Random.html#) |----------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Random](https://developer.android.com/reference/kotlin/java/util/Random.html#)! | [from](https://developer.android.com/reference/kotlin/java/util/Random.html#from(java.util.random.RandomGenerator))`(`generator:` `[RandomGenerator](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#)!`)`
Returns an instance of`Random`that delegates method calls to the[RandomGenerator](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#)argument. If the generator is an instance of`Random`, it is returned. Otherwise, this method returns an instance of`Random`that delegates all methods except`setSeed`to the generator. The returned instance's`setSeed`method always throws[UnsupportedOperationException](https://developer.android.com/reference/kotlin/java/lang/UnsupportedOperationException.html#). The returned instance is not serializable.
| | [Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html) | [nextBytes](https://developer.android.com/reference/kotlin/java/util/Random.html#nextBytes(kotlin.ByteArray))`(`bytes:` `[ByteArray](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-byte-array/index.html)!`)`
Generates random bytes and places them into a user-supplied byte array. The number of random bytes produced is equal to the length of the byte array.
| | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextGaussian](https://developer.android.com/reference/kotlin/java/util/Random.html#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. The general contract of`nextGaussian`is that one`double`value, chosen from (approximately) the usual normal distribution with mean`0.0`and standard deviation`1.0`, is pseudorandomly generated and returned.
| ||
| From class[RandomGenerator](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#) |------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html) | [isDeprecated](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#isDeprecated())`()`
Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.
| | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextDouble](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextDouble(kotlin.Double))`(`bound:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)`
Returns a pseudorandomly chosen`double`value between zero (inclusive) and the specified bound (exclusive).
| | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextDouble](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextDouble(kotlin.Double,%20kotlin.Double))`(`origin:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`, `bound:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)`
Returns a pseudorandomly chosen`double`value between the specified origin (inclusive) and the specified bound (exclusive).
| | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextExponential](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextExponential())`()`
Returns a nonnegative`double`value pseudorandomly chosen from an exponential distribution whose mean is 1.
| | [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | [nextFloat](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextFloat(kotlin.Float))`(`bound:` `[Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html)`)`
Returns a pseudorandomly chosen`float`value between zero (inclusive) and the specified bound (exclusive).
| | [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | [nextFloat](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextFloat(kotlin.Float,%20kotlin.Float))`(`origin:` `[Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html)`, `bound:` `[Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html)`)`
Returns a pseudorandomly chosen`float`value between the specified origin (inclusive) and the specified bound (exclusive).
| | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | [nextGaussian](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextGaussian(kotlin.Double,%20kotlin.Double))`(`mean:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`, `stddev:` `[Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html)`)`
Returns a`double`value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.
| | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [nextInt](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextInt(kotlin.Int,%20kotlin.Int))`(`origin:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`, `bound:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)`
Returns a pseudorandomly chosen`int`value between the specified origin (inclusive) and the specified bound (exclusive).
| | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | [nextLong](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextLong(kotlin.Long))`(`bound:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)`
Returns a pseudorandomly chosen`long`value between zero (inclusive) and the specified bound (exclusive).
| | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | [nextLong](https://developer.android.com/reference/kotlin/java/util/random/RandomGenerator.html#nextLong(kotlin.Long,%20kotlin.Long))`(`origin:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `bound:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`)`
Returns a pseudorandomly chosen`long`value between the specified origin (inclusive) and the specified bound (exclusive).
| ||
## Public methods
### current
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
static fun current(): ThreadLocalRandom!
```
Returns the current thread's`ThreadLocalRandom`object. Methods of this object should be called only by the current thread, not by other threads.
| Return ||
|--------------------------------------------------------------------------------------------------------------|-----------------------------------------|
| [ThreadLocalRandom](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom#)! | the current thread's`ThreadLocalRandom` |
### doubles
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
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()](https://developer.android.com/reference/kotlin/java/util/Random.html#nextDouble()).
| Return ||
|-----------------------------------------------------------------------------------------------------|----------------------------------------|
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | a stream of pseudorandom`double`values |
### doubles
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
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](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the origin (inclusive) of each random value |
| `randomNumberBound` | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the bound (exclusive) of each random value |
| Return ||
|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | 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](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
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()](https://developer.android.com/reference/kotlin/java/util/Random.html#nextDouble()).
| Parameters ||
|--------------|---------------------------------------------------------------------------------------------------------------|
| `streamSize` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the number of values to generate |
| Return ||
|-----------------------------------------------------------------------------------------------------|---------------------------|
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | a stream of`double`values |
| Exceptions ||
|--------------------------------------|---------------------------------|
| `java.lang.IllegalArgumentException` | if`streamSize`is less than zero |
### doubles
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
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](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the number of values to generate |
| `randomNumberOrigin` | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the origin (inclusive) of each random value |
| `randomNumberBound` | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the bound (exclusive) of each random value |
| Return ||
|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
| [DoubleStream](https://developer.android.com/reference/kotlin/java/util/stream/DoubleStream.html#)! | 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` |
### ints
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun ints(): IntStream!
```
Returns an effectively unlimited stream of pseudorandom`int`values.
A pseudorandom`int`value is generated as if it's the result of calling the method[nextInt()](https://developer.android.com/reference/kotlin/java/util/Random.html#nextInt()).
| Return ||
|-----------------------------------------------------------------------------------------------|-------------------------------------|
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | a stream of pseudorandom`int`values |
### ints
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun ints(
randomNumberOrigin: Int,
randomNumberBound: Int
): IntStream!
```
Returns an effectively unlimited stream of pseudorandom`int`values, each conforming to the given origin (inclusive) and bound (exclusive).
A pseudorandom`int`value is generated as if it's the result of calling the following method with the origin and bound:
```kotlin
int nextInt(int origin, int bound) {
int n = bound - origin;
if (n > 0) {
return nextInt(n) + origin;
}
else { // range not representable as int
int r;
do {
r = nextInt();
} while (r < origin || r >= bound);
return r;
}
}
```
| Parameters ||
|----------------------|------------------------------------------------------------------------------------------------------------------------|
| `randomNumberOrigin` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the origin (inclusive) of each random value |
| `randomNumberBound` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the bound (exclusive) of each random value |
| Return ||
|-----------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------|
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | a stream of pseudorandom`int`values, each with the given origin (inclusive) and bound (exclusive) |
| Exceptions ||
|--------------------------------------|----------------------------------------------------------------------|
| `java.lang.IllegalArgumentException` | if`randomNumberOrigin`is greater than or equal to`randomNumberBound` |
### ints
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun ints(streamSize: Long): IntStream!
```
Returns a stream producing the given`streamSize`number of pseudorandom`int`values.
A pseudorandom`int`value is generated as if it's the result of calling the method[nextInt()](https://developer.android.com/reference/kotlin/java/util/Random.html#nextInt()).
| Parameters ||
|--------------|---------------------------------------------------------------------------------------------------------------|
| `streamSize` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the number of values to generate |
| Return ||
|-----------------------------------------------------------------------------------------------|-------------------------------------|
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | a stream of pseudorandom`int`values |
| Exceptions ||
|--------------------------------------|---------------------------------|
| `java.lang.IllegalArgumentException` | if`streamSize`is less than zero |
### ints
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun ints(
streamSize: Long,
randomNumberOrigin: Int,
randomNumberBound: Int
): IntStream!
```
Returns a stream producing the given`streamSize`number of pseudorandom`int`values, each conforming to the given origin (inclusive) and bound (exclusive).
A pseudorandom`int`value is generated as if it's the result of calling the following method with the origin and bound:
```kotlin
int nextInt(int origin, int bound) {
int n = bound - origin;
if (n > 0) {
return nextInt(n) + origin;
}
else { // range not representable as int
int r;
do {
r = nextInt();
} while (r < origin || r >= bound);
return r;
}
}
```
| Parameters ||
|----------------------|------------------------------------------------------------------------------------------------------------------------|
| `streamSize` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the number of values to generate |
| `randomNumberOrigin` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the origin (inclusive) of each random value |
| `randomNumberBound` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the bound (exclusive) of each random value |
| Return ||
|-----------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------|
| [IntStream](https://developer.android.com/reference/kotlin/java/util/stream/IntStream.html#)! | a stream of pseudorandom`int`values, each with the given origin (inclusive) and bound (exclusive) |
| Exceptions ||
|--------------------------------------|-------------------------------------------------------------------------------------------------------|
| `java.lang.IllegalArgumentException` | if`streamSize`is less than zero, or`randomNumberOrigin`is greater than or equal to`randomNumberBound` |
### longs
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun longs(): LongStream!
```
Returns an effectively unlimited stream of pseudorandom`long`values.
A pseudorandom`long`value is generated as if it's the result of calling the method[nextLong()](https://developer.android.com/reference/kotlin/java/util/Random.html#nextLong()).
| Return ||
|-------------------------------------------------------------------------------------------------|--------------------------------------|
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | a stream of pseudorandom`long`values |
### longs
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun longs(streamSize: Long): LongStream!
```
Returns a stream producing the given`streamSize`number of pseudorandom`long`values.
A pseudorandom`long`value is generated as if it's the result of calling the method[nextLong()](https://developer.android.com/reference/kotlin/java/util/Random.html#nextLong()).
| Parameters ||
|--------------|---------------------------------------------------------------------------------------------------------------|
| `streamSize` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the number of values to generate |
| Return ||
|-------------------------------------------------------------------------------------------------|--------------------------------------|
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | a stream of pseudorandom`long`values |
| Exceptions ||
|--------------------------------------|---------------------------------|
| `java.lang.IllegalArgumentException` | if`streamSize`is less than zero |
### longs
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun longs(
randomNumberOrigin: Long,
randomNumberBound: Long
): LongStream!
```
Returns an effectively unlimited stream of pseudorandom`long`values, each conforming to the given origin (inclusive) and bound (exclusive).
A pseudorandom`long`value is generated as if it's the result of calling the following method with the origin and bound:
```kotlin
long nextLong(long origin, long bound) {
long r = nextLong();
long n = bound - origin, m = n - 1;
if ((n & m) == 0L) // power of two
r = (r & m) + origin;
else if (n > 0L) { // reject over-represented candidates
for (long u = r >>> 1; // ensure nonnegative
u + m - (r = u % n) < 0L; // rejection check
u = nextLong() >>> 1) // retry
;
r += origin;
}
else { // range not representable as long
while (r < origin || r >= bound)
r = nextLong();
}
return r;
}
```
| Parameters ||
|----------------------|--------------------------------------------------------------------------------------------------------------------------|
| `randomNumberOrigin` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the origin (inclusive) of each random value |
| `randomNumberBound` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the bound (exclusive) of each random value |
| Return ||
|-------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | a stream of pseudorandom`long`values, each with the given origin (inclusive) and bound (exclusive) |
| Exceptions ||
|--------------------------------------|----------------------------------------------------------------------|
| `java.lang.IllegalArgumentException` | if`randomNumberOrigin`is greater than or equal to`randomNumberBound` |
### longs
Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun longs(
streamSize: Long,
randomNumberOrigin: Long,
randomNumberBound: Long
): LongStream!
```
Returns a stream producing the given`streamSize`number of pseudorandom`long`, each conforming to the given origin (inclusive) and bound (exclusive).
A pseudorandom`long`value is generated as if it's the result of calling the following method with the origin and bound:
```kotlin
long nextLong(long origin, long bound) {
long r = nextLong();
long n = bound - origin, m = n - 1;
if ((n & m) == 0L) // power of two
r = (r & m) + origin;
else if (n > 0L) { // reject over-represented candidates
for (long u = r >>> 1; // ensure nonnegative
u + m - (r = u % n) < 0L; // rejection check
u = nextLong() >>> 1) // retry
;
r += origin;
}
else { // range not representable as long
while (r < origin || r >= bound)
r = nextLong();
}
return r;
}
```
| Parameters ||
|----------------------|--------------------------------------------------------------------------------------------------------------------------|
| `streamSize` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the number of values to generate |
| `randomNumberOrigin` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the origin (inclusive) of each random value |
| `randomNumberBound` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the bound (exclusive) of each random value |
| Return ||
|-------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
| [LongStream](https://developer.android.com/reference/kotlin/java/util/stream/LongStream.html#)! | a stream of pseudorandom`long`values, each with the given origin (inclusive) and bound (exclusive) |
| Exceptions ||
|--------------------------------------|-------------------------------------------------------------------------------------------------------|
| `java.lang.IllegalArgumentException` | if`streamSize`is less than zero, or`randomNumberOrigin`is greater than or equal to`randomNumberBound` |
### nextBoolean
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextBoolean(): Boolean
```
Returns the next pseudorandom, uniformly distributed`boolean`value from this random number generator's sequence. The general contract of`nextBoolean`is that one`boolean`value is pseudorandomly generated and returned. The values`true`and`false`are produced with (approximately) equal probability.
| Return ||
|------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|
| [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html) | the next pseudorandom, uniformly distributed`boolean`value from this random number generator's sequence |
### nextDouble
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextDouble(): Double
```
Returns the next pseudorandom, uniformly distributed`double`value between`0.0`and`1.0`from this random number generator's sequence.
The general contract of`nextDouble`is that one`double`value, chosen (approximately) uniformly from the range`0.0d`(inclusive) to`1.0d`(exclusive), is pseudorandomly generated and returned.
| Return ||
|----------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
| [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | the next pseudorandom, uniformly distributed`double`value between`0.0`and`1.0`from this random number generator's sequence |
### nextDouble
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextDouble(bound: Double): Double
```
Returns a pseudorandomly chosen`double`value between zero (inclusive) and the specified bound (exclusive).
| Parameters ||
|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `bound` | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the upper bound (exclusive) for the returned value. Must be positive and finite |
| Return ||
|----------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------|
| [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | a pseudorandomly chosen`double`value between zero (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|------------------------------------------|
| `java.lang.IllegalArgumentException` | if`bound`is not both positive and finite |
### nextDouble
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextDouble(
origin: Double,
bound: Double
): Double
```
Returns a pseudorandomly chosen`double`value between the specified origin (inclusive) and the specified bound (exclusive).
| Parameters ||
|----------|-------------------------------------------------------------------------------------------------------------------------------------|
| `origin` | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the least value that can be returned |
| `bound` | [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html):the upper bound (exclusive) for the returned value |
| Return ||
|----------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|
| [Double](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/index.html) | a pseudorandomly chosen`double`value between the origin (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|-----------------------------------------------------------------------------------------------|
| `java.lang.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 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextFloat(): Float
```
Returns the next pseudorandom, uniformly distributed`float`value between`0.0`and`1.0`from this random number generator's sequence.
The general contract of`nextFloat`is that one`float`value, chosen (approximately) uniformly from the range`0.0f`(inclusive) to`1.0f`(exclusive), is pseudorandomly generated and returned. All 224 possible`float`values of the form*m x* 2-24, where*m*is a positive integer less than 224, are produced with (approximately) equal probability.
| Return ||
|--------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
| [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | the next pseudorandom, uniformly distributed`float`value between`0.0f`and`1.0f`from this random number generator's sequence |
### nextFloat
Added in[API level 35](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextFloat(bound: Float): Float
```
Returns a pseudorandomly chosen`float`value between zero (inclusive) and the specified bound (exclusive).
| Parameters ||
|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `bound` | [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html):the upper bound (exclusive) for the returned value. Must be positive and finite |
| Return ||
|--------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|
| [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | a pseudorandomly chosen`float`value between zero (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|------------------------------------------|
| `java.lang.IllegalArgumentException` | if`bound`is not both positive and finite |
### nextFloat
Added in[API level 35](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextFloat(
origin: Float,
bound: Float
): Float
```
Returns a pseudorandomly chosen`float`value between the specified origin (inclusive) and the specified bound (exclusive).
| Parameters ||
|----------|---------------------------------------------------------------------------------------------------------------------|
| `origin` | [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html):the least value that can be returned |
| `bound` | [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html):the upper bound (exclusive) |
| Return ||
|--------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------|
| [Float](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/index.html) | a pseudorandomly chosen`float`value between the origin (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|-----------------------------------------------------------------------------------------------|
| `java.lang.IllegalArgumentException` | if`origin`is not finite, or`bound`is not finite, or`origin`is greater than or equal to`bound` |
### nextInt
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextInt(): Int
```
Returns the next pseudorandom, uniformly distributed`int`value from this random number generator's sequence. The general contract of`nextInt`is that one`int`value is pseudorandomly generated and returned. All 232 possible`int`values are produced with (approximately) equal probability.
| Return ||
|----------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | the next pseudorandom, uniformly distributed`int`value from this random number generator's sequence |
### nextInt
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextInt(bound: Int): Int
```
Returns a pseudorandom, uniformly distributed`int`value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. The general contract of`nextInt`is that one`int`value in the specified range is pseudorandomly generated and returned. All`bound`possible`int`values are produced with (approximately) equal probability.
| Parameters ||
|---------|---------------------------------------------------------------------------------------------------------------------------|
| `bound` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the upper bound (exclusive). Must be positive. |
| Return ||
|----------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------|
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | the next pseudorandom, uniformly distributed`int`value between zero (inclusive) and`bound`(exclusive) from this random number generator's sequence |
| Exceptions ||
|--------------------------------------|--------------------------|
| `java.lang.IllegalArgumentException` | if bound is not positive |
### nextInt
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextInt(
origin: Int,
bound: Int
): Int
```
Returns a pseudorandomly chosen`int`value between the specified origin (inclusive) and the specified bound (exclusive).
| Parameters ||
|----------|-------------------------------------------------------------------------------------------------------------------------------|
| `origin` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the least value that can be returned |
| `bound` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):the upper bound (exclusive) for the returned value |
| Return ||
|----------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | a pseudorandomly chosen`int`value between the origin (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|----------------------------------------------|
| `java.lang.IllegalArgumentException` | if`origin`is greater than or equal to`bound` |
### nextLong
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextLong(): Long
```
Returns the next pseudorandom, uniformly distributed`long`value from this random number generator's sequence. The general contract of`nextLong`is that one`long`value is pseudorandomly generated and returned.
| Return ||
|------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
| [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | the next pseudorandom, uniformly distributed`long`value from this random number generator's sequence |
### nextLong
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextLong(bound: Long): Long
```
Returns a pseudorandomly chosen`long`value between zero (inclusive) and the specified bound (exclusive).
| Parameters ||
|---------|----------------------------------------------------------------------------------------------------------------------------------------------------|
| `bound` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the upper bound (exclusive) for the returned value. Must be positive. |
| Return ||
|------------------------------------------------------------------------------|---------------------------------------------------------------------------------------|
| [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | a pseudorandomly chosen`long`value between zero (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|--------------------------|
| `java.lang.IllegalArgumentException` | if`bound`is not positive |
### nextLong
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun nextLong(
origin: Long,
bound: Long
): Long
```
Returns a pseudorandomly chosen`long`value between the specified origin (inclusive) and the specified bound (exclusive).
| Parameters ||
|----------|---------------------------------------------------------------------------------------------------------------------------------|
| `origin` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the least value that can be returned |
| `bound` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the upper bound (exclusive) for the returned value |
| Return ||
|------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
| [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | a pseudorandomly chosen`long`value between the origin (inclusive) and the bound (exclusive) |
| Exceptions ||
|--------------------------------------|----------------------------------------------|
| `java.lang.IllegalArgumentException` | if`origin`is greater than or equal to`bound` |
### setSeed
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
fun setSeed(seed: Long): Unit
```
Throws`UnsupportedOperationException`. Setting seeds in this generator is not supported.
| Parameters ||
|--------|---------------------------------------------------------------------------------------------|
| `seed` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the seed value |
| Exceptions ||
|-------------------------------------------|--------|
| `java.lang.UnsupportedOperationException` | always |
## Protected methods
### next
Added in[API level 21](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
```
protected fun next(bits: Int): Int
```
Generates a pseudorandom number with the indicated number of low-order bits. Because this class has no subclasses, this method cannot be invoked or overridden.
| Parameters ||
|--------|----------------------------------------------------------------------------------------|
| `bits` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):random bits |
| Return ||
|----------------------------------------------------------------------------|--------------------------------------------------------------------------|
| [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | the next pseudorandom value from this random number generator's sequence |