Random

Random

Random ()

创建一个新的随机数生成器。 此构造函数将随机数生成器的种子设置为非常可能与此构造函数的任何其他调用不同的值。

Random

Random (long seed)

使用一个long种子创建一个新的随机数生成器。 种子是由方法next(int)维护的伪随机数生成器的内部状态的初始值。

调用 new Random(seed)相当于：

 Random rnd = new Random();
 rnd.setSeed(seed);

doubles

DoubleStream doubles (long streamSize)

返回产生给定的 streamSize个数的伪随机数 streamSize数据流，每个数值介于零（含）和1（ double ）之间。

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

doubles

DoubleStream doubles ()

返回伪随机 double值的有效无限流，每个值都在零（含）和一（独占）之间。

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

doubles

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

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;
 }

ints

IntStream ints (long streamSize)

返回产生所述给定流 streamSize数的伪随机的 int值。

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

ints

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

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

IntStream ints ()

返回伪随机值 int的有效无限流。

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

longs

LongStream longs ()

返回伪随机 long值的有效无限流。

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

longs

LongStream longs (long streamSize)

返回产生给定 streamSize个数的伪随机数 long值的流。

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

longs

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

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;
 }

nextBoolean

boolean nextBoolean ()

返回下一个伪，均匀分布boolean从这个随机数生成器的序列值。 nextBoolean的总体合同是一个boolean值被伪随机生成并返回。 值（ true和false ）以（近似）相等的概率产生。

方法 nextBoolean由类 Random实现，就像通过：

 public boolean nextBoolean() {
   return next(1) != 0;
 }

nextBytes

void nextBytes (byte[] bytes)

生成随机字节并将它们放入用户提供的字节数组中。 产生的随机字节数等于字节数组的长度。

方法 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;
 }

nextDouble

double nextDouble ()

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

nextDouble的一般合约是从 0.0d （含）至 1.0d （不包括）范围内统一选择（近似）的一个 double值，伪随机生成并返回。

方法 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);

nextFloat

float nextFloat ()

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

nextFloat的总体合同是从0.0f （含）至1.0f （不包括）范围内统一选择（近似）一个float值，伪随机生成并返回。 所有2 ^24个可能的float值的形式m x 2 ^-24 ，其中m是一个小于2 ²⁴的正整数，以（近似）相等的概率产生。

方法 nextFloat由类 Random实现，如同通过：

 public float nextFloat() {
   return next(24) / ((float)(1 << 24));
 }

仅在前面的描述中使用了“近似”对冲，因为下一个方法仅仅是近似独立选择比特的无偏差源。 如果它是随机选择比特的完美来源，则所示算法将从所述范围中选择float值，并具有完全一致性。

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

 return next(30) / ((float)(1 << 30));

nextGaussian

double nextGaussian ()

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

nextGaussian的一般合约是从（大约）平均值 0.0和标准偏差 1.0的通常正态分布中选择的一个 double值被伪随机地生成并返回。

方法 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;
   }
 }

nextInt

int nextInt ()

返回下一个伪，均匀分布int从这个随机数生成器的序列值。 nextInt的总体合同是一个int值被伪随机地生成并返回。 所有2 ^32个可能的int值都以（近似）相等的概率产生。

方法 nextInt由类 Random实现，如同通过：

 public int nextInt() {
   return next(32);
 }

nextInt

int nextInt (int n)

返回伪随机的，均匀分布int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。 nextInt的一般合同是指定范围内的一个int值被伪随机地生成并返回。 所有n可能的int值都以（近似）相等的概率产生。 方法nextInt(int n)由类Random实现，如同通过：

 public int nextInt(int n) {
   if (n <= 0)
     throw new IllegalArgumentException("n must be positive");

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

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

仅在前面的描述中使用了“近似”对冲，因为下一个方法仅仅是近似独立选择比特的无偏差源。 如果它是随机选择比特的完美来源，则所示算法将从所述范围中选择int值，并具有完美的均匀性。

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

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

nextLong

long nextLong ()

返回下一个伪，均匀分布long从这个随机数生成器的序列值。 nextLong的总体合同是一个long值被伪随机地生成并返回。

方法 nextLong由类 Random实现，就像通过：

 public long nextLong() {
   return ((long)next(32) << 32) + next(32);
 }

setSeed

void setSeed (long seed)

使用一个long种子设置此随机数生成器的种子。 setSeed的一般合约是它改变了这个随机数字生成器对象的状态，以便处于与刚刚以参数seed作为种子创建的完全相同的状态。 方法setSeed由类Random通过原子更新种子为

(seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)

setSeed类Random恰好只使用给定种子的48位。 一般地，然而，压倒一切的方法可以使用的所有64位long参数作为种子值。

next

int next (int bits)

生成下一个伪随机数。 子类应该覆盖这个，因为这被所有其他方法使用。

next的一般合约是它返回一个int值，如果参数bits在1和32 （含）之间，那么返回值的许多低位将是（近似）独立选择的位值，其中每一个（大致）相同可能是0或1 。 方法next由类Random通过原子更新种子为

(seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)

(int)(seed >>> (48 - bits)).