SplittableRandom (Java Platform SE 8 )

java.lang.Object
- java.util.SplittableRandom

```
public final class SplittableRandom
extends Object
```
适用于（在其他上下文中）使用可能产生子任务的孤立并行计算的均匀伪随机值的生成器。类SplittableRandom支持方法用于生产类型的伪随机数int ， long和double具有类似用途作为类Random但在以下方面不同：
- 系列生成值通过了DieHarder套件测试随机数发生器的独立性和均匀性。（最近使用version 3.31.1进行了验证。）这些测试仅验证某些类型和范围的方法，但是类似的属性预期至少约为其他类型。期间（其重复之前的任何一系列生成值的长度）至少为2 ⁶⁴ 。
- 方法split()构造并返回与当前实例共享不可变状态的新SplitableRandom实例。然而，以非常高的概率，由两个对象共同生成的值具有与使用单个SplittableRandom对象的单个线程生成相同数量的值相同的统计特性。
- SplittableRandom的实例不是线程安全的。它们被设计为跨线程分割，不共享。例如， fork/join-style计算使用随机数可能包括以下形式的建设new Subtask(aSplittableRandom.split()).fork() 。
- 该类提供了用于生成随机流的附加方法，在stream.parallel()模式下使用上述技术。
SplittableRandom的SplittableRandom不是加密安全的。考虑在安全敏感的应用程序中使用SecureRandom。此外，默认构造的实例不使用加密随机种子，除非88465688849997 java.util.secureRandomSeed设置为true 。
从以下版本开始：

1.8

构造方法摘要

构造方法
Constructor and Description
`SplittableRandom()` 创建一个新的SplittableRandom实例，可能会生成与当前程序中任何其他实例统计上独立的值序列; 并且通常可以在程序调用中变化。
`SplittableRandom(long seed)` 使用指定的初始种子创建一个新的SplittableRandom实例。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`DoubleStream`	`doubles()` 返回一个有效的无限流的伪随机`double`值从该发生器和/或一个从它分裂; 每个值在零（包括）和一（独占）之间。
`DoubleStream`	`doubles(double randomNumberOrigin, double randomNumberBound)` 返回一个有效的无限流的伪随机`double`值从这个发生器和/或一个从它分裂; 每个值符合给定的起始（包括）和绑定（排他）。
`DoubleStream`	`doubles(long streamSize)` 返回一个流，产生给定的`streamSize`数`double`数值从该发生器和/或一个从它分裂; 每个值在零（包括）和一（独占）之间。
`DoubleStream`	`doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)` 返回一个流，产生给定的`streamSize`数`double`值从该发生器和/或从它的一个分割; 每个值符合给定的起始（包括）和绑定（排他）。
`IntStream`	`ints()` 返回一个有效的无限流的伪随机 `int`值从这个发生器和/或一个从它分裂。
`IntStream`	`ints(int randomNumberOrigin, int randomNumberBound)` 返回一个有效的无限流的伪随机数`int`从这个发生器和/或一个从它分裂的值; 每个值符合给定的起始（包括）和绑定（排他）。
`IntStream`	`ints(long streamSize)` 返回一个流，产生给定的 `streamSize`数 `int`值从该发生器和/或从它的一个拆分。
`IntStream`	`ints(long streamSize, int randomNumberOrigin, int randomNumberBound)` 返回一个流，产生给定的`streamSize`数量的伪随机`int`值来自该发生器和/或从其分离一个; 每个值符合给定的起始（包括）和绑定（排他）。
`LongStream`	`longs()` 返回一个有效的无限流的伪随机 `long`值从该生成器和/或一个从它分割。
`LongStream`	`longs(long streamSize)` 返回一个流，产生给定的 `streamSize`数 `long`值从该发生器和/或一个从它分裂。
`LongStream`	`longs(long randomNumberOrigin, long randomNumberBound)` 返回一个有效的无限流的伪随机`long`值从这个发生器和/或一个从它分裂; 每个值符合给定的起始（包括）和绑定（排他）。
`LongStream`	`longs(long streamSize, long randomNumberOrigin, long randomNumberBound)` 返回一个流，产生给定的`streamSize`数`long`值从该发生器和/或一个从它分裂; 每个值符合给定的起始（包括）和绑定（排他）。
`boolean`	`nextBoolean()` 返回一个伪 `boolean`值 `boolean` 。
`double`	`nextDouble()` 返回零（包括）和一（独占）之间的伪 `double`值double。
`double`	`nextDouble(double bound)` 返回0.0（含）和指定边界（排除）之间的伪随机 `double`值。
`double`	`nextDouble(double origin, double bound)` 返回指定的起始（包括）和绑定（排除）之间的伪 `double`值double。
`int`	`nextInt()` 返回一个伪 `int`值 `int` 。
`int`	`nextInt(int bound)` 返回一个伪零符号 `int`之间的零（含）和指定的界限（排除）之间的值。
`int`	`nextInt(int origin, int bound)` 返回指定的起始点（含）和指定的边界（排除）之间的伪 `int`值int。
`long`	`nextLong()` 返回一个伪 `long`值 `long` 。
`long`	`nextLong(long bound)` 返回零（含）和指定边界（排除）之间的伪 `long`值long。
`long`	`nextLong(long origin, long bound)` 返回指定的起始点（包括）和指定的绑定（排除）之间的伪 `long`值long。
`SplittableRandom`	`split()` 构造并返回一个新的SplittableRandom实例，与该实例共享不可变状态。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造方法详细信息
  - SplittableRandom
```
public SplittableRandom(long seed)
```
    使用指定的初始种子创建一个新的SplittableRandom实例。在同一程序中使用相同种子创建的SplittableRandom实例生成相同的值序列。
    
    参数
    
    seed - 初始种子
  - SplittableRandom
```
public SplittableRandom()
```
    创建一个新的SplittableRandom实例，可能会生成与当前程序中任何其他实例统计上独立的值序列; 并且通常可以在程序调用中变化。
- 方法详细信息
  - split
```
public SplittableRandom split()
```
    构造并返回一个新的SplittableRandom实例，与该实例共享不可变状态。然而，以非常高的概率，由两个对象共同生成的值集合具有与使用单个SplittableRandom对象的单个线程生成相同数量的值相同的统计属性。可以使用split()方法进一步拆分两个对象中的一个或两个，并且相同的预期统计属性适用于通过这种递归拆分构造的整个生成器集合。
    
    结果
    
    新的SplittableRandom实例
  - nextInt
```
public int nextInt()
```
    返回一个伪 int值 int 。
    
    结果
    
    一个伪 int值
  - nextInt
```
public int nextInt(int bound)
```
    返回零（包括）和指定边界（排除）之间的伪随机 int值。
    
    参数
    
    bound - 上限（独占）。必须是积极的。
    
    结果
    
    一个伪随机 int之间的零（包括）和绑定（独占）
    
    异常
    
    IllegalArgumentException - 如果 bound
  - nextInt
```
public int nextInt(int origin,
                   int bound)
```
    返回指定的起始点（包括）与指定的边界（排除）之间的伪 int值int。
    
    参数
    
    origin - 返回的最小值
    
    bound - 上限（独占）
    
    结果
    
    原始（包括）和绑定（排他性）之间的伪随机 int值
    
    异常
    
    IllegalArgumentException - 如果 origin大于等于 bound
  - nextLong
```
public long nextLong()
```
    返回一个伪 long值 long 。
    
    结果
    
    一个伪 long值
  - nextLong
```
public long nextLong(long bound)
```
    返回一个伪零符号 long在零（含）和指定的界限（排除）之间的值。
    
    参数
    
    bound - 上限（独占）。必须是积极的。
    
    结果
    
    零（包括）和绑定（独占）之间的伪随机 long值
    
    异常
    
    IllegalArgumentException - 如果 bound
  - nextLong
```
public long nextLong(long origin,
                     long bound)
```
    返回指定的起始（含）和指定的绑定（排除）之间的伪 long值long。
    
    参数
    
    origin - 返回的最小值
    
    bound - 上限（独占）
    
    结果
    
    原始（含）和限制（独占）之间的伪随机 long值
    
    异常
    
    IllegalArgumentException - 如果 origin大于等于 bound
  - nextDouble
```
public double nextDouble()
```
    返回在零（包括）和一（独占）之间的伪随机 double值。
    
    结果
    
    一个伪随机 double之间的零（含）和一（独占）
  - nextDouble
```
public double nextDouble(double bound)
```
    返回0.0（含）和指定边界（排除）之间的伪随机 double值。
    
    参数
    
    bound - 上限（独占）。必须是积极的。
    
    结果
    
    零（包括）和绑定（独占）之间的伪随机 double值
    
    异常
    
    IllegalArgumentException - 如果 bound
  - nextDouble
```
public double nextDouble(double origin,
                         double bound)
```
    返回指定原点（包括）和绑定（排除）之间的伪 double值double。
    
    参数
    
    origin - 返回的最小值
    
    bound - 上限（独占）
    
    结果
    
    原始（含）和绑定（排他性）之间的伪随机 double值
    
    异常
    
    IllegalArgumentException - 如果 origin大于或等于 bound
  - nextBoolean
```
public boolean nextBoolean()
```
    返回一个伪 boolean值 boolean 。
    
    结果
    
    一个伪 boolean值
  - ints
```
public IntStream ints(long streamSize)
```
    返回一个流，产生给定的 streamSize数 int值从该发生器和/或一个从它分裂。
    
    参数
    
    streamSize - 要生成的值的数量
    
    结果
    
    一串 int值
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零
  - ints
```
public IntStream ints()
```
    返回一个有效的无限流的伪随机 int值从这个发生器和/或一个从它分裂。
    
    Implementation Note:
    
    该方法实现等同于 ints(Long.MAX_VALUE) 。
    
    结果
    
    一串 int值
  - ints
```
public IntStream ints(long streamSize,
                      int randomNumberOrigin,
                      int randomNumberBound)
```
    返回一个流，产生给定的streamSize数int值，该值来自该发生器和/或从其分离; 每个值符合给定的起始（包括）和绑定（排他）。
    
    参数
    
    streamSize - 要生成的值的数量
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 int流（int），每个都有给定的来源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零，或 randomNumberOrigin大于或等于 randomNumberBound
  - ints
```
public IntStream ints(int randomNumberOrigin,
                      int randomNumberBound)
```
    返回一个有效的无限流的伪随机int值从这个发生器和/或一个从它分裂; 每个值符合给定的起始（包括）和绑定（排他）。
    
    Implementation Note:
    
    该方法实现为等效于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
    
    参数
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 int的流量 int ，每个都有给定的来源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
  - longs
```
public LongStream longs(long streamSize)
```
    返回一个流，该流产生给定的 streamSize数 long数值，来自该发生器和/或一次分割。
    
    参数
    
    streamSize - 要生成的值的数量
    
    结果
    
    一串 long值
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零
  - longs
```
public LongStream longs()
```
    从这个发生器返回一个有效的无限制的伪随机流 long值，和/或从其中分离出一个值。
    
    Implementation Note:
    
    该方法实现为等效于 longs(Long.MAX_VALUE) 。
    
    结果
    
    一串 long值
  - longs
```
public LongStream longs(long streamSize,
                        long randomNumberOrigin,
                        long randomNumberBound)
```
    返回一个流，产生给定的streamSize数long值，该值来自该发生器和/或从其分离; 每个值符合给定的起始（包括）和绑定（排他）。
    
    参数
    
    streamSize - 要生成的值的数量
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 long流（long），每个都有给定的来源（包括）和绑定（独占）
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零，或 randomNumberOrigin大于等于 randomNumberBound
  - longs
```
public LongStream longs(long randomNumberOrigin,
                        long randomNumberBound)
```
    返回一个有效的无限流的伪随机数long值从这个发生器和/或一个从它分裂; 每个值符合给定的起始（包括）和绑定（排他）。
    
    Implementation Note:
    
    该方法实现等同于 longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
    
    参数
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 long流long，每个都有给定的起源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 randomNumberOrigin大于等于 randomNumberBound
  - doubles
```
public DoubleStream doubles(long streamSize)
```
    返回一个流，产生给定的streamSize数double值，该值来自该发生器和/或从其分离; 每个值在零（包括）和一（独占）之间。
    
    参数
    
    streamSize - 要生成的值的数量
    
    结果
    
    double值
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零
  - doubles
```
public DoubleStream doubles()
```
    返回一个有效的无限流的伪随机double值从这个发生器和/或一个从它分裂; 每个值在零（包括）和一（独占）之间。
    
    Implementation Note:
    
    该方法实现等同于 doubles(Long.MAX_VALUE) 。
    
    结果
    
    一串 double值
  - doubles
```
public DoubleStream doubles(long streamSize,
                            double randomNumberOrigin,
                            double randomNumberBound)
```
    返回一个流，产生给定的streamSize数量的伪double值double来自该发生器和/或从其double值; 每个值符合给定的起始（包括）和绑定（排他）。
    
    参数
    
    streamSize - 要生成的值的数量
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 double流double，每个都有给定的来源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零
    
    IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
  - doubles
```
public DoubleStream doubles(double randomNumberOrigin,
                            double randomNumberBound)
```
    返回一个有效的无限流的伪随机double值来自该发生器和/或一个从它分裂的值; 每个值符合给定的起始（包括）和绑定（排他）。
    
    Implementation Note:
    
    该方法实现等同于 doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
    
    参数
    
    randomNumberOrigin - 每个随机值的起始（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 double流double，每个都有给定的来源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 randomNumberOrigin大于等于 randomNumberBound

Class SplittableRandom

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

构造方法详细信息

SplittableRandom

SplittableRandom

方法详细信息

split

nextInt

nextInt

nextInt

nextLong

nextLong

nextLong

nextDouble

nextDouble

nextDouble

nextBoolean

ints

ints

ints

ints

longs

longs

longs

longs

doubles

doubles

doubles

doubles