Module  java.base
软件包  java.util

Class SplittableRandom



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

    SplittableRandom实例不是加密安全的。 考虑在安全敏感的应用程序中使用SecureRandom 此外,默认构造的实例不使用加密随机种子,除非system property java.util.secureRandomSeed设置为true

    从以下版本开始:
    1.8
    • 构造方法摘要

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

      所有方法  接口方法  具体的方法 
      Modifier and Type 方法 描述
      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
      double nextDouble​()
      返回零(含)和一(独占)之间的伪随机值 double
      double nextDouble​(double bound)
      返回值在0.0(含)之间的伪随机 double和指定的绑定(排除)之间。
      double nextDouble​(double origin, double bound)
      返回指定的起始(包括)和绑定(排除)之间的伪随机值 double
      int nextInt​()
      返回伪随机数 int值。
      int nextInt​(int bound)
      返回0(包括)和指定的bound(exclusive)之间的伪随机值 int
      int nextInt​(int origin, int bound)
      返回指定的原点(含)和指定的界限(排除)之间的伪随机值 int
      long nextLong​()
      返回一个伪随机值 long
      long nextLong​(long bound)
      返回0(包括)和指定的bound(exclusive)之间的伪随机值 long
      long nextLong​(long origin, long bound)
      返回指定的起始(含)和指定的界限(排除)之间的伪随机值 long
      SplittableRandom split​()
      构造并返回一个新的SplittableRandom实例,与该实例共享不可变状态。
    • 构造方法详细信息

      • 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
      • nextInt

        public int nextInt​(int bound)
        返回0(包括)和指定的绑定(排除)之间的伪随机 int值。
        参数
        bound - 上限(独占)。 必须是积极的。
        结果
        零(包括)和绑定(独占)之间的伪随机值 int
        异常
        IllegalArgumentException - 如果 bound
      • nextInt

        public int nextInt​(int origin,
                           int bound)
        返回指定的原点(含)和指定的界限(排除)之间的伪随机值 int
        参数
        origin - 返回的值最小
        bound - 上限(独占)
        结果
        原始(含)和绑定(排他性)之间的伪随机数 int
        异常
        IllegalArgumentException - 如果 origin大于或等于 bound
      • nextLong

        public long nextLong​()
        返回伪随机值 long
        结果
        一个伪随机的 long
      • nextLong

        public long nextLong​(long bound)
        返回0(包括)和指定的bound(exclusive)之间的伪随机值 long
        参数
        bound - 上限(独占)。 必须是积极的。
        结果
        一个伪随机 longlong在零(包括)和绑定(独占)之间的值
        异常
        IllegalArgumentException - 如果 bound
      • nextLong

        public long nextLong​(long origin,
                             long bound)
        返回指定的起始(含)和指定的界限(排除)之间的伪随机值 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
        参数
        origin - 返回的值最小
        bound - 上限(独占)
        结果
        原始(含)和限制(排他性)之间的伪随机值 double
        异常
        IllegalArgumentException - 如果 origin大于或等于 bound
      • nextBoolean

        public boolean nextBoolean​()
        返回一个伪随机数 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 ,每个都有给定的来源(包括)和绑定(排他)
        异常
        IllegalArgumentException - 如果 streamSize小于零,或 randomNumberOrigin大于或等于 randomNumberBound
      • ints

        public IntStream ints​(int randomNumberOrigin,
                              int randomNumberBound)
        返回一个有效的无限流的伪随机数int来自该发生器和/或从它的一个分割值; 每个值符合给定的起始(包括)和绑定(排他)。
        Implementation Note:
        该方法实现为等同于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
        参数
        randomNumberOrigin - 每个随机值的起点(含)
        randomNumberBound - 每个随机值的绑定(排他)
        结果
        伪随机流 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 - 每个随机值的绑定(排他)
        结果
        一个伪随机 longlong ,每个都有给定的来源(包括)和绑定(排他)
        异常
        IllegalArgumentException - 如果 streamSize小于零,或 randomNumberOrigin大于或等于 randomNumberBound
      • longs

        public LongStream longs​(long randomNumberOrigin,
                                long randomNumberBound)
        返回一个有效的无限流的伪随机数long来自该发生器和/或从它的一个分裂值; 每个值符合给定的起始(包括)和绑定(排他)。
        Implementation Note:
        该方法实现为等同于 longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
        参数
        randomNumberOrigin - 每个随机值的起点(含)
        randomNumberBound - 每个随机值的绑定(排他)
        结果
        一个伪随机数( 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值,该值来自该发生器和/或从其分离; 每个值符合给定的起始(包括)和绑定(排他)。
        参数
        streamSize - 要生成的值的数量
        randomNumberOrigin - 每个随机值的起点(含)
        randomNumberBound - 每个随机值的绑定(排他)
        结果
        一个伪随机数( double ,每个都有给定的来源(包括)和绑定(排他)
        异常
        IllegalArgumentException - 如果 streamSize小于零,或 randomNumberOrigin大于或等于 randomNumberBound
      • doubles

        public DoubleStream doubles​(double randomNumberOrigin,
                                    double randomNumberBound)
        返回一个有效的无限流的伪随机数double从这个发生器和/或从它的一个分裂值; 每个值符合给定的起始(包括)和绑定(排他)。
        Implementation Note:
        该方法实现为等同于 doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
        参数
        randomNumberOrigin - 每个随机值的起点(含)
        randomNumberBound - 每个随机值的绑定(排他)
        结果
        一个伪随机数( double ,每个都有给定的来源(包括)和绑定(独占)
        异常
        IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound