模块 java.base
包 java.util.random

接口 RandomGenerator

所有已知的子接口：
RandomGenerator.ArbitrarilyJumpableGenerator , RandomGenerator.JumpableGenerator , RandomGenerator.LeapableGenerator , RandomGenerator.SplittableGenerator , RandomGenerator.StreamableGenerator
所有已知的实现类：
Random , SecureRandom , SplittableRandom , ThreadLocalRandom
public interface RandomGenerator
RandomGenerator 接口旨在为生成随机或（更典型的）伪随机数字序列（或boolean）的对象提供通用协议。这样的序列可以通过重复调用返回单个伪随机选择值的方法，或者通过调用返回伪随机选择值流的方法来获得。

理想情况下，给定隐式或显式指定的值范围，每个值都将从该范围内独立且统一地选择。在实践中，人们可能不得不满足于某种近似于独立性和统一性。

对于 int 、 long 和 boolean 值，如果没有明确指定范围，则范围包括该类型的所有可能值。在 float 和 double 值的情况下，首先总是从 2 的集合中统一选择一个值w介于 0.0（含）和 1.0（不含）之间的值，其中w对于float值是Float.PRECISION ，对于double值是Double.PRECISION ，使得相邻值相差2−w（注意这个集合是子集的一组所有可表示的浮点值介于 0.0（含）和 1.0（不含）之间）；然后，如果指定了一个明确的范围，则所选数字会在计算上进行缩放和转换，以便看起来是从该明确范围内大致均匀地选择的。

每个返回流的方法都会产生一个值流，每个值的选择方式与返回单个伪随机选择值的方法相同。例如，如果 r 实现 RandomGenerator ，则方法调用 r.ints(100) 返回 100 个 int 值的流。如果 r.nextInt() 被调用 100 次，这些值不一定与返回的值完全相同；所有可以保证的是流中的每个值都是从相同范围内以类似的伪随机方式选择的。

假定使用伪随机算法实现 RandomGenerator 接口的每个对象都包含有限数量的状态。使用这样的对象来生成伪随机选择的值会通过计算新状态作为当前状态的函数来改变其状态，而不参考当前状态以外的任何信息。这种对象的不同可能状态的数量称为它的时期（RandomGenerator 接口的一些实现可能是真正随机的而不是伪随机的，例如依赖于物理对象的统计行为来导出所选值。这样的实现没有固定的周期。）

通常，实现 RandomGenerator 接口的对象不需要是线程安全的。建议多线程应用程序使用 ThreadLocalRandom 或（最好）实现 RandomGenerator.SplittableGenerator 或 RandomGenerator.JumpableGenerator 接口的伪随机数生成器。

实现 RandomGenerator 的对象通常不是加密安全的。考虑改为使用 SecureRandom 来获取密码安全的伪随机数生成器，以供对安全敏感的应用程序使用。但是请注意，SecureRandom 确实实现了 RandomGenerator 接口，因此 SecureRandom 的实例可以在不需要安全生成器的应用程序中与其他类型的伪随机生成器互换使用。

除非另有明确说明，否则对任何方法参数使用 null 都会导致 NullPointerException。

自从：
17

  • 内部类总结

    内部类
    修饰符和类型
    接口
    描述
    static interface 
    RandomGenerator.ArbitrarilyJumpableGenerator
    该接口旨在为生成伪随机值序列的对象提供通用协议，并且可以轻松地跳向前，任意量，到状态周期中的一个遥远的点。
    static interface 
    RandomGenerator.JumpableGenerator
    该接口旨在为生成伪随机值的对象提供通用协议，并且可以轻松地跳远期，适量（例如 264) 到状态循环中的一个遥远的点。
    static interface 
    RandomGenerator.LeapableGenerator
    该接口旨在为生成伪随机值序列的对象提供通用协议，并且不仅可以轻松跳转，还可以轻松跳转。飞跃远期，大量（例如 2128), 到状态周期中一个非常遥远的点。
    static interface 
    RandomGenerator.SplittableGenerator
    该接口旨在为生成伪随机值序列的对象提供通用协议，并且可以split分为两个对象（原始对象和新对象），每个对象都遵循相同的协议（因此可以无限期地递归拆分）。
    static interface 
    RandomGenerator.StreamableGenerator
    RandomGenerator.StreamableGenerator 接口增强了 RandomGenerator 接口以提供返回 RandomGenerator 对象流的方法。

  • 方法总结

    修饰符和类型
    方法
    描述
    default DoubleStream
    doubles()
    返回伪随机选择的 double 值的有效无限流。
    default DoubleStream
    doubles(double randomNumberOrigin, double randomNumberBound)
    返回一个有效无限的伪随机选择的 double 值流，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
    default DoubleStream
    doubles(long streamSize)
    返回产生给定 streamSize 个伪随机选择的 double 值的流。
    default DoubleStream
    doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
    返回一个流，该流产生给定的 streamSize 个伪随机选择的 double 值，其中每个值都在指定的原点（包括）和指定的边界（不包括）之间。
    static RandomGenerator
    getDefault()
    返回一个 RandomGenerator 满足具有一个状态位大于或等于 64 的 算法 的最低要求。
    default IntStream
    ints()
    返回伪随机选择的 int 值的有效无限流。
    default IntStream
    ints(int randomNumberOrigin, int randomNumberBound)
    返回一个有效无限的伪随机选择的 int 值流，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
    default IntStream
    ints(long streamSize)
    返回产生给定 streamSize 个伪随机选择的 int 值的流。
    default IntStream
    ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
    返回一个流，该流产生给定的 streamSize 个伪随机选择的 int 值，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
    default boolean
    isDeprecated()
    如果 RandomGenerator（算法）的实现已被标记为弃用，则返回 true。
    default LongStream
    longs()
    返回伪随机选择的 long 值的有效无限流。
    default LongStream
    longs(long streamSize)
    返回产生给定 streamSize 个伪随机选择的 long 值的流。
    default LongStream
    longs(long randomNumberOrigin, long randomNumberBound)
    返回伪随机选择的有效无限流 long 值，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
    default LongStream
    longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
    返回一个流，该流产生给定的 streamSize 个伪随机选择的 long 值，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
    default boolean
    nextBoolean()
    返回伪随机选择的 boolean 值。
    default void
    nextBytes(byte[] bytes)
    使用从 -128（含）和 127（含）之间的值范围内均匀随机选择的生成字节值填充用户提供的字节数组。
    default double
    nextDouble()
    返回介于零（含）和一（不含）之间的伪随机值 double 值。
    default double
    nextDouble(double bound)
    返回介于零（含）和指定界限（不含）之间的伪随机选择的 double 值。
    default double
    nextDouble(double origin, double bound)
    返回指定原点（含）和指定边界（不含）之间伪随机选择的 double 值。
    default double
    nextExponential()
    返回从均值为 1 的指数分布中伪随机选择的非负 double 值。
    default float
    nextFloat()
    返回介于零（含）和一（不含）之间的伪随机 float 值。
    default float
    nextFloat(float bound)
    返回介于零（含）和指定界限（不含）之间的伪随机选择的 float 值。
    default float
    nextFloat(float origin, float bound)
    返回指定原点（含）和指定边界（不含）之间伪随机选择的 float 值。
    default double
    nextGaussian()
    返回从均值为 0 且标准差为 1 的高斯（正态）分布中伪随机选择的 double 值。
    default double
    nextGaussian(double mean, double stddev)
    返回从高斯（正态）分布中伪随机选择的 double 值，其均值和标准差由参数指定。
    default int
    nextInt()
    返回伪随机选择的 int 值。
    default int
    nextInt(int bound)
    返回介于零（含）和指定界限（不含）之间的伪随机选择的 int 值。
    default int
    nextInt(int origin, int bound)
    返回指定原点（含）和指定边界（不含）之间伪随机选择的 int 值。
    long
    nextLong()
    返回伪随机选择的 long 值。
    default long
    nextLong(long bound)
    返回介于零（含）和指定界限（不含）之间的伪随机选择的 long 值。
    default long
    nextLong(long origin, long bound)
    返回指定原点（含）和指定边界（不含）之间伪随机选择的 long 值。
    static RandomGenerator
    of(String name)
    返回使用 name 算法 的 RandomGenerator 实例。

  • 方法详情

    • of

      static RandomGenerator  of(String  name)
      返回使用 name 算法 的 RandomGenerator 实例。
      参数：
      name - 随机数生成器的名称 算法
      返回：
      RandomGenerator 的实例
      抛出：
      NullPointerException - 如果名称为空
      IllegalArgumentException - 如果找不到指定的算法

    • getDefault

      static RandomGenerator  getDefault()
      返回一个 RandomGenerator 满足具有一个状态位大于或等于 64 的 算法 的最低要求。
      实现要求：
      由于算法会随着时间的推移而改进，因此无法保证此方法会随着时间的推移返回相同的算法。

      默认实现选择 L32X64MixRandom。

      返回：
      RandomGenerator

    • isDeprecated

      default boolean isDeprecated()
      如果 RandomGenerator（算法）的实现已被标记为弃用，则返回 true。
      实现要求：
      默认实现检查 @Deprecated 注解。
      实现注意事项：
      随机数生成器算法随时间演变；将引入新算法，旧算法将失去地位。如果旧算法被认为不适合继续使用，它将被标记为已弃用，以表明它可能会在将来的某个时候被删除。
      返回：
      如果 RandomGenerator（算法）的实现已被标记为弃用，则为真

    • doubles

      default DoubleStream  doubles()
      返回伪随机选择的 double 值的有效无限流。
      实现要求：
      默认实现产生一个重复调用nextDouble () 的顺序流。
      实现注意事项：
      允许以等同于 doubles (Long.MAX_VALUE ) 的方式实现此方法。
      返回：
      伪随机选择的 double 值流

    • doubles

      default DoubleStream  doubles(double randomNumberOrigin, double randomNumberBound)
      返回一个有效无限的伪随机选择的 double 值流，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
      实现要求：
      默认实现生成重复调用 nextDouble (randomNumberOrigin, randomNumberBound) 的顺序流。
      实现注意事项：
      允许以等同于 doubles (Long.MAX_VALUE , randomNumberOrigin, randomNumberBound) 的方式实现此方法。
      参数：
      randomNumberOrigin - 可以产生的最小值
      randomNumberBound - 产生的每个值的上限（不包括）
      返回：
      伪随机选择的 double 值流，每个值都在指定的原点（包括）和指定的边界（不包括）之间
      抛出：
      IllegalArgumentException - 如果 randomNumberOrigin 不是有限的，或者 randomNumberBound 不是有限的，或者 randomNumberOrigin 大于或等于 randomNumberBound

    • doubles

      default DoubleStream  doubles(long streamSize)
      返回产生给定 streamSize 个伪随机选择的 double 值的流。
      实现要求：
      默认实现生成重复调用 nextDouble() 的顺序流。
      参数：
      streamSize - 要生成的值的数量
      返回：
      伪随机选择的 double 值流
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零

    • doubles

      default DoubleStream  doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
      返回一个流，该流产生给定的 streamSize 个伪随机选择的 double 值，其中每个值都在指定的原点（包括）和指定的边界（不包括）之间。
      实现要求：
      默认实现生成重复调用 nextDouble (randomNumberOrigin, randomNumberBound) 的顺序流。
      参数：
      streamSize - 要生成的值的数量
      randomNumberOrigin - 可以产生的最小值
      randomNumberBound - 产生的每个值的上限（不包括）
      返回：
      伪随机选择的 double 值流，每个值都在指定的原点（包括）和指定的边界（不包括）之间
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零，或者 randomNumberOrigin 不是有限的，或者 randomNumberBound 不是有限的，或者 randomNumberOrigin 大于或等于 randomNumberBound

    • ints

      default IntStream  ints()
      返回伪随机选择的 int 值的有效无限流。
      实现要求：
      默认实现产生一个重复调用nextInt () 的顺序流。
      实现注意事项：
      允许以等同于 ints (Long.MAX_VALUE ) 的方式实现此方法。
      返回：
      伪随机选择的 int 值流

    • ints

      default IntStream  ints(int randomNumberOrigin, int randomNumberBound)
      返回一个有效无限的伪随机选择的 int 值流，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
      实现要求：
      默认实现生成重复调用 nextInt (randomNumberOrigin, randomNumberBound) 的顺序流。
      实现注意事项：
      允许以等同于 ints (Long.MAX_VALUE , randomNumberOrigin, randomNumberBound) 的方式实现此方法。
      参数：
      randomNumberOrigin - 可以产生的最小值
      randomNumberBound - 产生的每个值的上限（不包括）
      返回：
      伪随机选择的 int 值流，每个值都在指定的原点（含）和指定的边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 randomNumberOrigin 大于或等于 randomNumberBound

    • ints

      default IntStream  ints(long streamSize)
      返回产生给定 streamSize 个伪随机选择的 int 值的流。
      实现要求：
      默认实现产生一个重复调用nextInt () 的顺序流。
      参数：
      streamSize - 要生成的值的数量
      返回：
      伪随机选择的 int 值流
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零

    • ints

      default IntStream  ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
      返回一个流，该流产生给定的 streamSize 个伪随机选择的 int 值，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
      实现要求：
      默认实现生成重复调用 nextInt (randomNumberOrigin, randomNumberBound) 的顺序流。
      参数：
      streamSize - 要生成的值的数量
      randomNumberOrigin - 可以产生的最小值
      randomNumberBound - 产生的每个值的上限（不包括）
      返回：
      伪随机选择的 int 值流，每个值都在指定的原点（含）和指定的边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零，或者 randomNumberOrigin 大于或等于 randomNumberBound

    • longs

      default LongStream  longs()
      返回伪随机选择的 long 值的有效无限流。
      实现要求：
      默认实现产生一个重复调用nextLong () 的顺序流。
      实现注意事项：
      允许以等同于 longs (Long.MAX_VALUE ) 的方式实现此方法。
      返回：
      伪随机选择的 long 值流

    • longs

      default LongStream  longs(long randomNumberOrigin, long randomNumberBound)
      返回伪随机选择的有效无限流 long 值，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
      实现要求：
      默认实现生成重复调用 nextLong (randomNumberOrigin, randomNumberBound) 的顺序流。
      实现注意事项：
      允许以等同于 longs (Long.MAX_VALUE , randomNumberOrigin, randomNumberBound) 的方式实现此方法。
      参数：
      randomNumberOrigin - 可以产生的最小值
      randomNumberBound - 产生的每个值的上限（不包括）
      返回：
      伪随机选择的 long 值流，每个值都在指定的原点（含）和指定的边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 randomNumberOrigin 大于或等于 randomNumberBound

    • longs

      default LongStream  longs(long streamSize)
      返回产生给定 streamSize 个伪随机选择的 long 值的流。
      实现要求：
      默认实现产生一个重复调用nextLong () 的顺序流。
      参数：
      streamSize - 要生成的值的数量
      返回：
      伪随机选择的 long 值流
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零

    • longs

      default LongStream  longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
      返回一个流，该流产生给定的 streamSize 个伪随机选择的 long 值，其中每个值都在指定的原点（含）和指定的边界（不含）之间。
      实现要求：
      默认实现生成重复调用 nextLong (randomNumberOrigin, randomNumberBound) 的顺序流。
      参数：
      streamSize - 要生成的值的数量
      randomNumberOrigin - 可以产生的最小值
      randomNumberBound - 产生的每个值的上限（不包括）
      返回：
      伪随机选择的 long 值流，每个值都在指定的原点（含）和指定的边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零，或者 randomNumberOrigin 大于或等于 randomNumberBound

    • nextBoolean

      default boolean nextBoolean()
      返回伪随机选择的 boolean 值。

      默认实现测试 nextInt () 产生的值的高位（符号位），因为某些伪随机数生成算法产生的值的高位比低位具有更好的统计质量。

      实现要求：
      默认实现根据 nextInt() 生成的数字的符号位生成结果。
      返回：
      伪随机选择的 boolean 值

    • nextBytes

      default void nextBytes(byte[] bytes)
      使用从 -128（含）和 127（含）之间的值范围内均匀随机选择的生成字节值填充用户提供的字节数组。
      实现要求：
      默认实现通过重复调用 nextLong() 产生结果。
      实现注意事项：
      用于填充字节数组的算法； 
      
      void nextBytes(byte[] bytes) {
        int i = 0;
        int len = bytes.length;
        for (int words = len >> 3; words--> 0; ) {
          long rnd = nextLong();
          for (int n = 8; n--> 0; rnd >>>= Byte.SIZE)
            bytes[i++] = (byte)rnd;
        }
        if (i < len)
          for (long rnd = nextLong(); i < len; rnd >>>= Byte.SIZE)
            bytes[i++] = (byte)rnd;
      }
      参数：
      bytes - 用伪随机字节填充的字节数组
      抛出：
      NullPointerException - 如果 bytes 为空

    • nextFloat

      default float nextFloat()
      返回介于零（含）和一（不含）之间的伪随机 float 值。
      实现要求：
      默认实现使用来自对 nextInt() 的调用的 Float.PRECISION 高位。
      返回：
      介于零（含）和一（不含）之间的伪随机值 float

    • nextFloat

      default float nextFloat(float bound)
      返回介于零（含）和指定界限（不含）之间的伪随机选择的 float 值。
      实现要求：
      默认实现检查 bound 是否为正有限浮点数。然后调用 nextFloat()，缩放结果，使最终结果位于 0.0f（含）和 bound（不含）之间。
      参数：
      bound - 返回值的上限（不包括）。必须是积极的和有限的
      返回：
      一个伪随机选择的 float 值介于零（含）和边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 bound 既不是正数也不是有限数

    • nextFloat

      default float nextFloat(float origin, float bound)
      返回指定原点（含）和指定边界（不含）之间伪随机选择的 float 值。
      实现要求：
      默认实现验证 origin 和 bound 是否有效，然后调用 nextFloat() 缩放并转换结果以适应 origin 和 bound（不包括）。
      参数：
      origin - 可以返回的最小值
      bound - 上限（不包括）
      返回：
      原点（含）和边界（不含）之间伪随机选择的 float 值
      抛出：
      IllegalArgumentException - 如果 origin 不是有限的，或者 bound 不是有限的，或者 origin 大于或等于 bound

    • nextDouble

      default double nextDouble()
      返回介于零（含）和一（不含）之间的伪随机值 double 值。
      实现要求：
      默认实现使用来自对 nextLong() 的调用的 Double.PRECISION 高位。
      返回：
      介于零（含）和一（不含）之间的伪随机值 double

    • nextDouble

      default double nextDouble(double bound)
      返回介于零（含）和指定界限（不含）之间的伪随机选择的 double 值。
      实现要求：
      默认实现检查 bound 是否为正有限双精度。然后调用 nextDouble()，缩放结果，使最终结果位于 0.0（含）和 bound（不含）之间。
      参数：
      bound - 返回值的上限（不包括）。必须是积极的和有限的
      返回：
      一个伪随机选择的 double 值介于零（含）和边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 bound 既不是正数也不是有限数

    • nextDouble

      default double nextDouble(double origin, double bound)
      返回指定原点（含）和指定边界（不含）之间伪随机选择的 double 值。
      实现要求：
      默认实现验证 origin 和 bound 是否有效，然后调用 nextDouble() 缩放并转换结果以适应 origin 和 bound（不包括）。
      参数：
      origin - 可以返回的最小值
      bound - 返回值的上限（不包括）
      返回：
      在原点（包括）和边界（不包括）之间伪随机选择的 double 值
      抛出：
      IllegalArgumentException - 如果 origin 不是有限的，或者 bound 不是有限的，或者 origin 大于或等于 bound

    • nextInt

      default int nextInt()
      返回伪随机选择的 int 值。
      实现要求：
      默认实现使用调用 nextLong () 的 32 个高位。
      返回：
      伪随机选择的 int 值

    • nextInt

      default int nextInt(int bound)
      返回介于零（含）和指定界限（不含）之间的伪随机选择的 int 值。
      实现要求：
      默认实现检查 bound 是否为正 int。然后调用 nextInt() ，将结果限制为大于或等于零且小于 bound 。如果 bound 是 2 的幂，则限制是一个简单的屏蔽操作。否则，将通过调用 nextInt() 重新计算结果，直到结果大于或等于零且小于 bound 。
      参数：
      bound - 返回值的上限（不包括）。必须是积极的。
      返回：
      一个伪随机选择的 int 值介于零（含）和边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 bound 不是正数

    • nextInt

      default int nextInt(int origin, int bound)
      返回指定原点（含）和指定边界（不含）之间伪随机选择的 int 值。
      实现要求：
      默认实现检查 origin 和 bound 是否为正 ints 。然后调用 nextInt() ，将结果限制为大于或等于 origin 且小于 bound 。如果 bound 是 2 的幂，则限制是一个简单的屏蔽操作。否则，将通过调用 nextInt() 重新计算结果，直到结果大于或等于 origin 且小于 bound 。
      参数：
      origin - 可以返回的最小值
      bound - 返回值的上限（不包括）
      返回：
      在原点（包括）和边界（不包括）之间伪随机选择的 int 值
      抛出：
      IllegalArgumentException - 如果 origin 大于或等于 bound

    • nextLong

      long nextLong()
      返回伪随机选择的 long 值。
      返回：
      伪随机选择的 long 值

    • nextLong

      default long nextLong(long bound)
      返回介于零（含）和指定界限（不含）之间的伪随机选择的 long 值。
      实现要求：
      默认实现检查 bound 是否为正 long。然后调用 nextLong() ，将结果限制为大于或等于零且小于 bound 。如果 bound 是 2 的幂，则限制是一个简单的屏蔽操作。否则，将通过调用 nextLong() 重新计算结果，直到结果大于或等于零且小于 bound 。
      参数：
      bound - 返回值的上限（不包括）。必须是积极的。
      返回：
      一个伪随机选择的 long 值介于零（含）和边界（不含）之间
      抛出：
      IllegalArgumentException - 如果 bound 不是正数

    • nextLong

      default long nextLong(long origin, long bound)
      返回指定原点（含）和指定边界（不含）之间伪随机选择的 long 值。
      实现要求：
      默认实现检查 origin 和 bound 是否为正 longs 。然后调用 nextLong() ，将结果限制为大于或等于 origin 且小于 bound 。如果 bound 是 2 的幂，则限制是一个简单的屏蔽操作。否则，将通过调用 nextLong() 重新计算结果，直到结果大于或等于 origin 且小于 bound 。
      参数：
      origin - 可以返回的最小值
      bound - 返回值的上限（不包括）
      返回：
      在原点（包括）和边界（不包括）之间伪随机选择的 long 值
      抛出：
      IllegalArgumentException - 如果 origin 大于或等于 bound

    • nextGaussian

      default double nextGaussian()
      返回从均值为 0 且标准差为 1 的高斯（正态）分布中伪随机选择的 double 值。
      实现要求：
      默认实现使用 McFarland 的快速修改 ziggurat 算法（主要是表驱动的，极少数情况下由计算和拒绝抽样处理）。用于对离散分布进行采样的 Walker 别名方法也发挥了作用。
      返回：
      从高斯分布中伪随机选择的 double 值

    • nextGaussian

      default double nextGaussian(double mean, double stddev)
      返回从高斯（正态）分布中伪随机选择的 double 值，其均值和标准差由参数指定。
      实现要求：
      默认实现使用 McFarland 的快速修改 ziggurat 算法（主要是表驱动的，极少数情况下由计算和拒绝抽样处理）。用于对离散分布进行采样的 Walker 别名方法也发挥了作用。
      参数：
      mean - 要从中得出的高斯分布的平均值
      stddev - 要从中得出的高斯分布的标准偏差（方差的平方根）
      返回：
      从指定的高斯分布中伪随机选择的 double 值
      抛出：
      IllegalArgumentException - 如果 stddev 为负

    • nextExponential

      default double nextExponential()
      返回从均值为 1 的指数分布中伪随机选择的非负 double 值。
      实现要求：
      默认实现使用 McFarland 的快速修改 ziggurat 算法（主要是表驱动的，极少数情况下由计算和拒绝抽样处理）。用于对离散分布进行采样的 Walker 别名方法也发挥了作用。
      返回：
      从指数分布中伪随机选择的非负 double 值