模块 java.base
包 java.util

类 Random

java.lang.Object
java.util.Random
所有已实现的接口：
Serializable , RandomGenerator
已知子类：
SecureRandom , ThreadLocalRandom
public class Random extends Object implements RandomGenerator , Serializable
此类的实例用于生成伪随机数流；它的周期只有 248.该类使用 48 位种子，使用线性同余公式对其进行修改。 （参见 Donald E. Knuth，计算机编程艺术，第 2 卷，第三版：半数值算法, 第 3.2.1 节。）

如果 Random 的两个实例使用相同的种子创建，并且对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证此属性，为类 Random 指定了特定算法。为了 Java 代码的绝对可移植性，Java 实现必须使用此处为类 Random 显示的所有算法。但是，类 Random 的子类可以使用其他算法，只要它们遵守所有方法的一般约定。

类 Random 实现的算法使用 protected 实用方法，每次调用可以提供多达 32 个伪随机生成的位。

许多应用程序会发现 Math.random() 方法更易于使用。

java.util.Random 的实例是线程安全的。但是，跨线程并发使用同一个java.util.Random实例可能会遇到争用和随之而来的性能低下。考虑在多线程设计中使用 ThreadLocalRandom 。

java.util.Random 的实例不是加密安全的。考虑改为使用 SecureRandom 来获取密码安全的伪随机数生成器，以供对安全敏感的应用程序使用。

自从：
1.0
参见：

  • 内部类总结

    在接口 java.util.random.RandomGenerator 中声明的嵌套类/接口

    RandomGenerator.ArbitrarilyJumpableGenerator, RandomGenerator.JumpableGenerator, RandomGenerator.LeapableGenerator, RandomGenerator.SplittableGenerator, RandomGenerator.StreamableGenerator

  • 构造方法总结

    构造方法
    构造方法
    描述
    Random()
    创建一个新的随机数生成器。
    Random(long seed)
    使用单个 long 种子创建一个新的随机数生成器。

  • 方法总结

    修饰符和类型
    方法
    描述
    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 的流，每个都符合给定的原点（包括）和边界（不包括）。
    protected int
    next(int bits)
    生成下一个伪随机数。
    boolean
    nextBoolean()
    从该随机数生成器的序列中返回下一个伪随机、均匀分布的 boolean 值。
    void
    nextBytes(byte[] bytes)
    生成随机字节并将它们放入用户提供的字节数组中。
    double
    nextDouble()
    从该随机数生成器的序列返回下一个伪随机值，均匀分布在 0.0 和 1.0 之间的 double 值。
    float
    nextFloat()
    从该随机数生成器的序列返回下一个伪随机值，均匀分布在 0.0 和 1.0 之间的 float 值。
    double
    nextGaussian()
    返回下一个伪随机，高斯（“正常”）分布 double 值，平均值为 0.0，标准差为 1.0，来自该随机数生成器的序列。
    int
    nextInt()
    从该随机数生成器的序列中返回下一个伪随机、均匀分布的 int 值。
    int
    nextInt(int bound)
    返回从该随机数生成器的序列中提取的伪随机、均匀分布的 int 值，介于 0（含）和指定值（不含）之间。
    long
    nextLong()
    从该随机数生成器的序列中返回下一个伪随机、均匀分布的 long 值。
    void
    setSeed(long seed)
    使用单个 long 种子设置此随机数生成器的种子。

    在类 java.lang.Object 中声明的方法

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    在接口 java.util.random.RandomGenerator 中声明的方法

    isDeprecated, nextDouble, nextDouble, nextExponential, nextFloat, nextFloat, nextGaussian, nextInt, nextLong, nextLong

  • 构造方法详细信息

    • Random

      public Random()
      创建一个新的随机数生成器。此构造方法将随机数生成器的种子设置为一个很可能与此构造方法的任何其他调用不同的值。

    • Random

      public Random(long seed)
      使用单个 long 种子创建一个新的随机数生成器。种子是由方法 next(int) 维护的伪随机数生成器的内部状态的初始值。
      实现要求：
      调用 new Random(seed) 等同于： 
      
 Random rnd = new Random();
 rnd.setSeed(seed);
      参数：
      seed - 初始种子
      参见：

  • 方法详情

    • setSeed

      public void setSeed(long seed)
      使用单个 long 种子设置此随机数生成器的种子。 setSeed 的一般契约是，它改变此随机数生成器对象的状态，使其处于与刚刚使用参数 seed 作为种子创建的状态完全相同的状态。方法 setSeed 由类 Random 实现，方法是将种子原子更新为 
      (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)
      并清除 nextGaussian() 使用的 haveNextNextGaussian 标志。

      Random 类对 setSeed 的实现恰好仅使用给定种子的 48 位。然而，一般来说，重写方法可以使用 long 参数的所有 64 位作为种子值。

      参数：
      seed - 初始种子

    • next

      protected int next(int bits)
      生成下一个伪随机数。子类应该重写它，因为它被所有其他方法使用。

      next 的一般约定是它返回一个 int 值，如果参数 bits 介于 1 和 32 之间（包含），则返回值的许多低位将是（大约）独立选择的位值，每个位值（大约）同样可能是 0 或 1 。方法 next 由类 Random 通过原子更新种子来实现

      (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)
      并返回 
      (int)(seed >>> (48 - bits)) .
      这是一个线性同余伪随机数生成器，由 DH Lehmer 定义并由 Donald E. Knuth 描述计算机编程艺术，第 2 卷，第三版：半数值算法, 第 3.2.1 节。
      参数：
      bits - 随机位
      返回：
      此随机数生成器序列中的下一个伪随机值
      自从：
      1.1

    • nextBytes

      public void nextBytes(byte[] bytes)
      生成随机字节并将它们放入用户提供的字节数组中。产生的随机字节数等于字节数组的长度。
      指定者：
      nextBytes 在接口 RandomGenerator 中
      实现要求：
      方法 nextBytes 由类 Random 实现，就好像由： 
      
 public void nextBytes(byte[] bytes) {
  for (int i = 0; i < bytes.length; )
   for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
     n-- > 0; rnd >>= 8)
    bytes[i++] = (byte)rnd;
 }
      参数：
      bytes - 用随机字节填充的字节数组
      抛出：
      NullPointerException - 如果字节数组为空
      自从：
      1.1

    • nextInt

      public int nextInt()
      从该随机数生成器的序列中返回下一个伪随机、均匀分布的 int 值。 nextInt 的一般契约是伪随机生成并返回一个 int 值。全部 232可能的 int 个值以（近似）相等的概率产生。
      指定者：
      nextInt 在接口 RandomGenerator 中
      实现要求：
      方法 nextInt 由类 Random 实现，就好像由： 
      
 public int nextInt() {
  return next(32);
 }
      返回：
      来自该随机数生成器序列的下一个伪随机、均匀分布的 int 值

    • nextInt

      public int nextInt(int bound)
      返回从该随机数生成器的序列中提取的伪随机、均匀分布的 int 值，介于 0（含）和指定值（不含）之间。 nextInt的一般契约是伪随机生成并返回指定范围内的一个int值。所有 bound 可能的 int 值都是以（近似）相等的概率产生的。
      指定者：
      nextInt 在接口 RandomGenerator 中
      实现要求：
      方法 nextInt(int bound) 由类 Random 实现，就好像由： 
      
 public int nextInt(int bound) {
  if (bound <= 0)
   throw new IllegalArgumentException("bound must be positive");

  if ((bound & -bound) == bound) // i.e., bound is a power of 2
   return (int)((bound * (long)next(31)) >> 31);

  int bits, val;
  do {
    bits = next(31);
    val = bits % bound;
  } while (bits - val + (bound-1) < 0);
  return val;
 }

      在前面的描述中使用对冲“大约”只是因为下一个方法只是大约独立选择的位的无偏源。如果它是随机选择位的完美来源，那么所示算法将从规定范围内完美均匀地选择 int 个值。

      该算法有点棘手。它拒绝会导致分布不均的值（由于 2^31 不能被 n 整除）。一个值被拒绝的概率取决于 n。最坏的情况是 n=2^30+1，拒绝的概率是 1/2，循环终止前预期的迭代次数是 2。

      该算法特别处理 n 是 2 的幂的情况：它从底层伪随机数生成器返回正确数量的高阶位。在没有特殊处理的情况下，正确的数量低阶位将被返回。众所周知，线性同余伪随机数生成器（例如由此类实现的伪随机数生成器）在其低阶位的值序列中具有较短的周期。因此，如果 n 是 2 的小幂，这种特殊情况会大大增加连续调用此方法返回的值序列的长度。

      参数：
      bound - 上限（不包括）。必须是积极的。
      返回：
      下一个伪随机数，均匀分布的 int 值介于零（含）和 bound（不含）之间，来自该随机数生成器的序列
      抛出：
      IllegalArgumentException - 如果绑定不是正数
      自从：
      1.2

    • nextLong

      public long nextLong()
      从该随机数生成器的序列中返回下一个伪随机、均匀分布的 long 值。 nextLong 的一般契约是伪随机生成并返回一个 long 值。
      指定者：
      nextLong 在接口 RandomGenerator 中
      实现要求：
      nextLong 方法由类 Random 实现，就好像通过： 
      
 public long nextLong() {
  return ((long)next(32) << 32) + next(32);
 }
      因为类 Random 使用只有 48 位的种子，所以该算法不会返回所有可能的 long 值。
      返回：
      来自该随机数生成器序列的下一个伪随机、均匀分布的 long 值

    • nextBoolean

      public boolean nextBoolean()
      从该随机数生成器的序列中返回下一个伪随机、均匀分布的 boolean 值。 nextBoolean 的一般契约是伪随机生成并返回一个 boolean 值。值 true 和 false 以（近似）相等的概率产生。
      指定者：
      nextBoolean 在接口 RandomGenerator 中
      实现要求：
      方法 nextBoolean 由类 Random 实现，就好像由： 
      
 public boolean nextBoolean() {
  return next(1) != 0;
 }
      返回：
      来自该随机数生成器序列的下一个伪随机、均匀分布的 boolean 值
      自从：
      1.2

    • nextFloat

      public float nextFloat()
      从该随机数生成器的序列返回下一个伪随机值，均匀分布在 0.0 和 1.0 之间的 float 值。

      nextFloat 的一般契约是伪随机生成并返回一个 float 值，从 0.0f（含）到 1.0f（不含）范围内（近似地）统一选择。全部 224可能的 float 形式的值MX2-24， 在哪里m是小于2的正整数24, 以（大约）相等的概率产生。

      指定者：
      nextFloat 在接口 RandomGenerator 中
      实现要求：
      方法 nextFloat 由类 Random 实现，就好像由： 
      
 public float nextFloat() {
  return next(24) / ((float)(1 << 24));
 }

      在前面的描述中使用对冲“大约”只是因为下一个方法只是大约独立选择的位的无偏源。如果它是随机选择位的完美来源，那么所示算法将从规定范围内完美均匀地选择 float 个值。

      [在 Java 的早期版本中，结果被错误地计算为：

       return next(30) / ((float)(1 << 30));
      这可能看起来是等效的，如果不是更好的话，但实际上它引入了轻微的不均匀性，因为浮点数舍入的偏差：有效数的低位更可能为 0比它会是 1.]
      返回：
      来自此随机数生成器序列的下一个伪随机、均匀分布在 0.0 和 1.0 之间的 float 值

    • nextDouble

      public double nextDouble()
      从该随机数生成器的序列返回下一个伪随机值，均匀分布在 0.0 和 1.0 之间的 double 值。

      nextDouble 的一般契约是一个 double 值，从 0.0d（含）到 1.0d（不含）范围内（近似地）均匀选择，伪随机生成并返回。

      指定者：
      nextDouble 在接口 RandomGenerator 中
      实现要求：
      方法 nextDouble 由类 Random 实现，就好像由： 
      
 public double nextDouble() {
  return (((long)next(26) << 27) + next(27))
   / (double)(1L << 53);
 }

      在前面的描述中使用对冲“大约”只是因为next 方法只是大约独立选择位的无偏源。如果它是随机选择位的完美来源，那么所示算法将从规定范围内完美均匀地选择 double 个值。

      [在 Java 的早期版本中，结果被错误地计算为：

       return (((long)next(27) << 27) + next(27)) / (double)(1L << 54);
      这可能看起来是等价的，如果不是更好的话，但实际上它引入了很大的不均匀性，因为浮点数舍入的偏差：有效数的低位可能是的三倍0 比它会是 1！这种不均匀性在实践中可能并不重要，但我们力求完美。]
      返回：
      下一个伪随机数，均匀分布在 0.0 和 1.0 之间的 double 值，来自该随机数生成器的序列
      参见：

    • nextGaussian

      public double nextGaussian()
      返回下一个伪随机，高斯（“正常”）分布 double 值，平均值为 0.0，标准差为 1.0，来自该随机数生成器的序列。

      nextGaussian 的一般契约是伪随机生成并返回一个 double 值，该值选自（近似）具有均值 0.0 和标准差 1.0 的通常正态分布。

      指定者：
      nextGaussian 在接口 RandomGenerator 中
      实现要求：
      方法 nextGaussian 由类 Random 实现，就好像由以下线程安全版本实现的一样： 
      
 private double nextNextGaussian;
 private boolean haveNextNextGaussian = false;

 public double nextGaussian() {
  if (haveNextNextGaussian) {
   haveNextNextGaussian = false;
   return nextNextGaussian;
  } else {
   double v1, v2, s;
   do {
    v1 = 2 * nextDouble() - 1;  // between -1.0 and 1.0
    v2 = 2 * nextDouble() - 1;  // between -1.0 and 1.0
    s = v1 * v1 + v2 * v2;
   } while (s >= 1 || s == 0);
   double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
   nextNextGaussian = v2 * multiplier;
   haveNextNextGaussian = true;
   return v1 * multiplier;
  }
 }
      这使用了极性法GEP Box、ME Muller 和 G. Marsaglia，正如 Donald E. Knuth 在计算机编程艺术，第 2 卷，第三版：半数值算法section 3.4.1, subsection C, algorithm P. 请注意，它仅以一次调用 StrictMath.log 和一次调用 StrictMath.sqrt 为代价生成两个独立的值。
      返回：
      下一个伪随机数，高斯（“正态”）分布 double 值，平均值为 0.0 ，标准差为 1.0 来自该随机数生成器的序列

    • ints

      public IntStream  ints(long streamSize)
      返回产生给定 streamSize 个伪随机数 int 值的流。

      生成伪随机 int 值，就好像它是调用方法 nextInt() 的结果一样。

      指定者：
      ints 在接口 RandomGenerator 中
      参数：
      streamSize - 要生成的值的数量
      返回：
      伪随机 int 值流
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零
      自从：
      1.8

    • ints

      public IntStream  ints()
      返回有效无限的伪随机 int 值流。

      生成伪随机 int 值，就好像它是调用方法 nextInt() 的结果一样。

      指定者：
      ints 在接口 RandomGenerator 中
      实现注意事项：
      此方法的实现等效于 ints(Long.MAX_VALUE) 。
      返回：
      伪随机 int 值流
      自从：
      1.8

    • ints

      public IntStream  ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
      返回产生给定 streamSize 伪随机数 int 值的流，每个值都符合给定的原点（包括）和边界（不包括）。

      生成一个伪随机 int 值，就好像它是使用原点和边界调用以下方法的结果：

       
 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;
  }
 }
      指定者：
      ints 在接口 RandomGenerator 中
      参数：
      streamSize - 要生成的值的数量
      randomNumberOrigin - 每个随机值的原点（含）
      randomNumberBound - 每个随机值的边界（不包括）
      返回：
      伪随机 int 值流，每个值都具有给定的原点（包括）和边界（不包括）
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零，或者 randomNumberOrigin 大于或等于 randomNumberBound
      自从：
      1.8

    • ints

      public IntStream  ints(int randomNumberOrigin, int randomNumberBound)
      返回一个有效的无限流伪随机 int 值，每个值都符合给定的原点（包括）和边界（不包括）。

      生成一个伪随机 int 值，就好像它是使用原点和边界调用以下方法的结果：

       
 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;
  }
 }
      指定者：
      ints 在接口 RandomGenerator 中
      实现注意事项：
      此方法的实现等效于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
      参数：
      randomNumberOrigin - 每个随机值的原点（含）
      randomNumberBound - 每个随机值的边界（不包括）
      返回：
      伪随机 int 值流，每个值都具有给定的原点（包括）和边界（不包括）
      抛出：
      IllegalArgumentException - 如果 randomNumberOrigin 大于或等于 randomNumberBound
      自从：
      1.8

    • longs

      public LongStream  longs(long streamSize)
      返回产生给定 streamSize 个伪随机数 long 值的流。

      生成伪随机值 long 就好像它是调用方法 nextLong() 的结果一样。

      指定者：
      longs 在接口 RandomGenerator 中
      参数：
      streamSize - 要生成的值的数量
      返回：
      伪随机 long 值流
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零
      自从：
      1.8

    • longs

      public LongStream  longs()
      返回有效无限的伪随机 long 值流。

      生成伪随机值 long 就好像它是调用方法 nextLong() 的结果一样。

      指定者：
      longs 在接口 RandomGenerator 中
      实现注意事项：
      此方法实现为等同于 longs(Long.MAX_VALUE) 。
      返回：
      伪随机 long 值流
      自从：
      1.8

    • longs

      public LongStream  longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
      返回产生给定 streamSize 伪随机数 long 的流，每个都符合给定的原点（包括）和边界（不包括）。

      生成一个伪随机 long 值，就好像它是使用原点和边界调用以下方法的结果：

       
 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;
 }
      指定者：
      longs 在接口 RandomGenerator 中
      参数：
      streamSize - 要生成的值的数量
      randomNumberOrigin - 每个随机值的原点（含）
      randomNumberBound - 每个随机值的边界（不包括）
      返回：
      伪随机 long 值流，每个值都具有给定的原点（包括）和边界（不包括）
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零，或者 randomNumberOrigin 大于或等于 randomNumberBound
      自从：
      1.8

    • longs

      public LongStream  longs(long randomNumberOrigin, long randomNumberBound)
      返回一个有效的无限流伪随机 long 值，每个值都符合给定的原点（包括）和边界（不包括）。

      生成一个伪随机 long 值，就好像它是使用原点和边界调用以下方法的结果：

       
 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;
 }
      指定者：
      longs 在接口 RandomGenerator 中
      实现注意事项：
      此方法实现为等同于 longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
      参数：
      randomNumberOrigin - 每个随机值的原点（含）
      randomNumberBound - 每个随机值的边界（不包括）
      返回：
      伪随机 long 值流，每个值都具有给定的原点（包括）和边界（不包括）
      抛出：
      IllegalArgumentException - 如果 randomNumberOrigin 大于或等于 randomNumberBound
      自从：
      1.8

    • doubles

      public DoubleStream  doubles(long streamSize)
      返回产生给定 streamSize 个伪随机数 double 值的流，每个值介于零（含）和一（不含）之间。

      生成伪随机值 double 就好像它是调用方法 nextDouble() 的结果一样。

      指定者：
      doubles 在接口 RandomGenerator 中
      参数：
      streamSize - 要生成的值的数量
      返回：
      double 值流
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零
      自从：
      1.8

    • doubles

      public DoubleStream  doubles()
      返回有效无限的伪随机 double 值流，每个值介于零（含）和一（不含）之间。

      生成伪随机值 double 就好像它是调用方法 nextDouble() 的结果一样。

      指定者：
      doubles 在接口 RandomGenerator 中
      实现注意事项：
      此方法实现为等同于 doubles(Long.MAX_VALUE) 。
      返回：
      伪随机 double 值流
      自从：
      1.8

    • doubles

      public DoubleStream  doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
      返回产生给定 streamSize 伪随机数 double 值的流，每个值都符合给定的原点（包括）和边界（不包括）。

      生成伪随机 double 值，就好像它是使用原点和边界调用以下方法的结果：

       
 double nextDouble(double origin, double bound) {
  double r = nextDouble();
  r = r * (bound - origin) + origin;
  if (r >= bound) // correct for rounding
   r = Math.nextDown(bound);
  return r;
 }
      指定者：
      doubles 在接口 RandomGenerator 中
      参数：
      streamSize - 要生成的值的数量
      randomNumberOrigin - 每个随机值的原点（含）
      randomNumberBound - 每个随机值的边界（不包括）
      返回：
      伪随机 double 值流，每个值都具有给定的原点（包括）和边界（不包括）
      抛出：
      IllegalArgumentException - 如果 streamSize 小于零，或者 randomNumberOrigin 不是有限的，或者 randomNumberBound 不是有限的，或者 randomNumberOrigin 大于或等于 randomNumberBound
      自从：
      1.8

    • doubles

      public DoubleStream  doubles(double randomNumberOrigin, double randomNumberBound)
      返回一个有效的无限流伪随机 double 值，每个值都符合给定的原点（包括）和边界（不包括）。

      生成伪随机 double 值，就好像它是使用原点和边界调用以下方法的结果：

       
 double nextDouble(double origin, double bound) {
  double r = nextDouble();
  r = r * (bound - origin) + origin;
  if (r >= bound) // correct for rounding
   r = Math.nextDown(bound);
  return r;
 }
      指定者：
      doubles 在接口 RandomGenerator 中
      实现注意事项：
      此方法的实现等效于 doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
      参数：
      randomNumberOrigin - 每个随机值的原点（含）
      randomNumberBound - 每个随机值的边界（不包括）
      返回：
      伪随机 double 值流，每个值都具有给定的原点（包括）和边界（不包括）
      抛出：
      IllegalArgumentException - 如果 randomNumberOrigin 大于或等于 randomNumberBound
      自从：
      1.8