compact1, compact2, compact3

java.util

Class Random

java.lang.Object

java.util.Random

All Implemented Interfaces:

Serializable

已知直接子类：

SecureRandom， ThreadLocalRandom

public class Random
extends Object
implements Serializable

这个类的一个实例是用于生成伪随机数流。该类使用一个48位的种子，这是使用线性同余公式的修正。（见Donald Knuth，计算机程序设计艺术，卷2 3.2.1节。）

如果Random两实例具有相同的种子创造，和方法调用相同的序列是由每个，他们将生成并返回数字的序列相同。为了保证这一特性，具体的算法是班级Random指定。java实现必须使用所有的算法在这里显示的类Random，为java代码绝对便携的缘故。然而，Random类子类允许使用其他的算法，只要他们坚持对所有方法的一般合同。

该算法的实现类Random使用protected实用方法，每次调用，可以供应32个伪随机产生的位。

许多应用程序将找到方法Math.random()简单使用。

实例java.util.Random是线程安全的。然而，同样的java.util.Random实例跨线程同时使用可能会遇到竞争和随之而来的性能差。考虑在多线程设计而使用ThreadLocalRandom。

实例java.util.Random不加密的安全。考虑使用SecureRandom得到加密的安全使用的安全敏感的应用伪随机数发生器。

从以下版本开始：

一

另请参见：

Serialized Form

构造方法摘要

构造方法

Constructor and Description
Random() 创建一个新的随机数发生器。
Random(long seed) 使用一个单一的 long种子创造了一种新的随机数发生器。

方法摘要

Modifier and Type	Method and Description
DoubleStream	doubles() 返回值伪随机 double有效无限流，每个零之间（含）一（独家）。
DoubleStream	doubles(double randomNumberOrigin, double randomNumberBound) 返回值伪随机 double有效无限流，每个符合给定的起源（含）和绑定（独家）。
DoubleStream	doubles(long streamSize) 返回一个流生产特定的伪随机 double值 streamSize数，每个零之间（含）一（独家）。
DoubleStream	doubles(long streamSize, double randomNumberOrigin, double randomNumberBound) 返回一个流生产特定的伪随机 double值 streamSize数，每个符合给定的起源（含）和绑定（独家）。
IntStream	ints() 返回值伪随机 int有效无限流。
IntStream	ints(int randomNumberOrigin, int randomNumberBound) 返回值伪随机 int有效无限流，每个符合给定的起源（含）和绑定（独家）。
IntStream	ints(long streamSize) 返回一个流生产特定的伪随机 int值 streamSize数。
IntStream	ints(long streamSize, int randomNumberOrigin, int randomNumberBound) 返回一个流生产特定的伪随机 int值 streamSize数，每个符合给定的起源（含）和绑定（独家）。
LongStream	longs() 返回值伪随机 long有效无限流。
LongStream	longs(long streamSize) 返回一个流生产特定的伪随机 long值 streamSize数。
LongStream	longs(long randomNumberOrigin, long randomNumberBound) 返回值伪随机 long有效无限流，每个符合给定的起源（含）和绑定（独家）。
LongStream	longs(long streamSize, long randomNumberOrigin, long randomNumberBound) 返回一个流生产特定的伪随机 long streamSize数，每个符合给定的起源（含）和绑定（独家）。
protected int	next(int bits) 生成下一个随机数。
boolean	nextBoolean() 返回下一个伪随机、均匀分布的 boolean价值从这个随机数生成器的序列。
void	nextBytes(byte[] bytes) 产生随机字节，并将它们放置到提供的字节数组中。
double	nextDouble() 返回下一个伪随机、均匀分布的 double价值 0.0和 1.0之间从这个随机数生成器的序列。
float	nextFloat() 返回下一个伪随机、均匀分布的 float价值 0.0和 1.0之间从这个随机数生成器的序列。
double	nextGaussian() 返回下一个伪随机，高斯（“正常”）的分布式 double均值和标准偏差值 0.0 1.0从这个随机数生成器的序列。
int	nextInt() 返回下一个伪随机、均匀分布的 int价值从这个随机数生成器的序列。
int	nextInt(int bound) 返回一个随机、均匀分布的 int值在0（含）和指定值（独家），从这个随机数发生器的顺序绘制。
long	nextLong() 返回下一个伪随机、均匀分布的 long价值从这个随机数生成器的序列。
void	setSeed(long seed) 集种子这个随机数发生器使用一个单一的 long种子。

Methods inherited from class java.lang.Object

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

Constructor Detail

Random

public Random()

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

Random

public Random(long seed)

使用一个单一的 long种子创造了一种新的随机数发生器。种子的伪随机数发生器的方法 next(int)保持内部状态的初始值。

调用new Random(seed)是等价的：

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

参数

seed -最初的种子

另请参见：

setSeed(long)

方法详细信息

setSeed

public void setSeed(long seed)

集种子这个随机数发生器使用一个单一的 long种子。对 setSeed总承包是改变这个随机数生成器对象的状态，以便在完全相同的状态，如果它只是争吵 seed作为种子创建。该方法是通过类的 setSeed Random自动更新种子

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

结算用的 haveNextNextGaussian

通过课堂的实施情况Random setSeed仅使用48位的种子。总的来说，然而，最重要的方法，可以使用64位的long论点作为一个种子值。

nextGaussian()旗实施。

参数

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))。

这是一个线性同余伪随机数发生器，由D. H. Lehmer和Donald E. Knuth在计算机程序设计艺术，描述3卷：半数值算法，第3.2.1。

参数

bits随机位

结果

下一个伪随机值，这个随机数生成器的序列

从以下版本开始：

一点一

nextBytes

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

参数

bytes -填充字节，字节数组

异常

NullPointerException如果字节数组是空的

从以下版本开始：

一点一

nextInt

public int nextInt()

返回下一个伪随机、均匀分布的 int价值从这个随机数生成器的序列。对 nextInt总承包是一 int值伪随机生成并返回。2 ^三十二 int值可能产生的概率相等（约）。

该方法是通过类nextInt Random如：

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

结果

下一个伪随机、均匀分布的 int价值从这个随机数生成器的序列

nextInt

public int nextInt(int bound)

返回一个随机、均匀分布的 int值在0（含）和指定值（独家），从这个随机数发生器的顺序绘制。对 nextInt一般合同是在指定的范围内的一 int值伪随机生成并返回。所有的 bound int值可能产生的概率相等（约）。该方法是通过类 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是一个功率的两个特别：它返回从底层的伪随机数发生器的正确数量的高阶位。在没有特殊待遇，对低阶位正确的号码将被退回。线性同余伪随机数发生器如一个该类实现的已经在他们的低阶位值序列的短周期。因此，这个特殊的情况下，大大增加了连续调用该方法返回的值的序列的长度，如果n是一个小的两个功率。

参数

bound -上限（独家）。必须是积极的。

结果

下一个伪随机、均匀分布的 int值之间的零（含）和 bound（独家）从这个随机数生成器的序列

异常

IllegalArgumentException -如果绑定不积极

从以下版本开始：

一点二

nextLong

public long nextLong()

返回下一个伪随机、均匀分布的 long价值从这个随机数生成器的序列。对 nextLong总承包是一 long值伪随机生成并返回。

该方法是通过类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 Random如：

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

结果

下一个伪随机、均匀分布的 boolean价值从这个随机数生成器的序列

从以下版本开始：

一点二

nextFloat

public float nextFloat()

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

对nextFloat总承包是一float值，选择（大约）均匀地从范围0.0f（含）至1.0f（独家），是伪随机生成并返回。所有的2^二十四可能float值的形式我 X 2^{- 24}，其中m是一个小于2^二十四正整数，产生的概率相等（约）。

该方法是通过类nextFloat Random如：

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

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

[在java的早期版本，错误的计算结果：

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

这似乎是等价的，如果没有更好的，但事实上它引入了一个轻微的不均匀性由于在浮点数舍入的偏见：这是更可能是有效的低阶位是0，它会是1。]

结果

下一个伪随机、均匀分布的 float价值 0.0和 1.0之间从这个随机数生成器的序列

nextDouble

public double nextDouble()

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

对nextDouble总承包是一double值，选择（大约）均匀地从范围0.0d（含）至1.0d（独家），是伪随机生成并返回。

该方法是通过类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，这将是！这种不一致性可能并不重要，在实践中，但我们追求完美。

结果

下一个伪随机、均匀分布的 double价值 0.0和 1.0之间从这个随机数生成器的序列

另请参见：

Math.random()

nextGaussian

public double nextGaussian()

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

对nextGaussian总承包是一double值，选择从（大约）均值和标准差1.0 0.0通常的正态分布，是伪随机生成并返回。

该方法是通过类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;
   }
 }

这使用E. P.盒，M. E. Muller的极坐标法和G. Marsaglia，就像Donald E. Knuth在计算机程序设计艺术，描述3卷：半数值算法，第3.4.1款C算法P.注意它产生两个独立的价值，在只有一个电话 StrictMath.log成本和一个叫 StrictMath.sqrt。

结果

接下来的伪高斯（“正常”）的分布式 double均值和标准偏差值 0.0 1.0从这个随机数生成器的序列

ints

public IntStream ints(long streamSize)

返回一个流生产特定的伪随机 int值 streamSize数。

伪随机int价值产生如它的调用方法nextInt()结果。

参数

streamSize -数量值生成

结果

一个流的伪随机 int值

异常

IllegalArgumentException -如果 streamSize小于零

从以下版本开始：

一点八

ints

public IntStream ints()

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

伪随机int价值产生如它的调用方法nextInt()结果。

Implementation Note:

此方法的实施相当于 ints(Long.MAX_VALUE)。

结果

一个流的伪随机 int值

从以下版本开始：

一点八

ints

public IntStream ints(long streamSize,
                      int randomNumberOrigin,
                      int randomNumberBound)

返回一个流生产特定的伪随机 int值 streamSize数，每个符合给定的起源（含）和绑定（独家）。

伪随机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;
   }
 }

参数

streamSize -数量值生成

randomNumberOrigin -起源（含）各随机值

randomNumberBound -束缚（独家）各随机值

结果

一个流的伪随机 int值，每个给定的起源（含）和绑定（独家）

异常

IllegalArgumentException -如果 streamSize小于零，或者 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

一点八

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

Implementation Note:

此方法的实施相当于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)。

参数

randomNumberOrigin -起源（含）各随机值

randomNumberBound -束缚（独家）各随机值

结果

一个流的伪随机 int值，每个给定的起源（含）和绑定（独家）

异常

IllegalArgumentException -如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

一点八

longs

public LongStream longs(long streamSize)

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

伪随机long价值产生如它的调用方法nextLong()结果。

参数

streamSize -数量值生成

结果

一个流的伪随机 long值

异常

IllegalArgumentException -如果 streamSize小于零

从以下版本开始：

一点八

longs

public LongStream longs()

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

伪随机long价值产生如它的调用方法nextLong()结果。

Implementation Note:

此方法的实施相当于 longs(Long.MAX_VALUE)。

结果

一个流的伪随机 long值

从以下版本开始：

一点八

longs

public LongStream longs(long streamSize,
                        long randomNumberOrigin,
                        long randomNumberBound)

返回一个流生产特定的伪随机 long streamSize数，每个符合给定的起源（含）和绑定（独家）。

伪随机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;
 }

参数

streamSize -数量值生成

randomNumberOrigin -起源（含）各随机值

randomNumberBound -束缚（独家）各随机值

结果

一个流的伪随机 long值，每个给定的起源（含）和绑定（独家）

异常

IllegalArgumentException -如果 streamSize小于零，或者 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

一点八

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

Implementation Note:

此方法的实施相当于 longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)。

参数

randomNumberOrigin -起源（含）各随机值

randomNumberBound -束缚（独家）各随机值

结果

一个流的伪随机 long值，每个给定的起源（含）和绑定（独家）

异常

IllegalArgumentException -如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

一点八

doubles

public DoubleStream doubles(long streamSize)

返回一个流生产特定的伪随机 double值 streamSize数，每个零之间（含）一（独家）。

伪随机double价值产生如它的调用方法的结果nextDouble() }。

参数

streamSize -数量值生成

结果

一股 double值

异常

IllegalArgumentException -如果 streamSize小于零

从以下版本开始：

一点八

doubles

public DoubleStream doubles()

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

伪随机double价值产生如它的调用方法nextDouble()结果}。

Implementation Note:

此方法的实施相当于 doubles(Long.MAX_VALUE)。

结果

一个流的伪随机 double值

从以下版本开始：

一点八

doubles

public DoubleStream doubles(long streamSize,
                            double randomNumberOrigin,
                            double randomNumberBound)

返回一个流生产特定的伪随机 double值 streamSize数，每个符合给定的起源（含）和绑定（独家）。

伪随机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;
 }

参数

streamSize -数量值生成

randomNumberOrigin -起源（含）各随机值

randomNumberBound -束缚（独家）各随机值

结果

一个流的伪随机 double值，每个给定的起源（含）和绑定（独家）

异常

IllegalArgumentException -如果 streamSize小于零

IllegalArgumentException -如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

一点八

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

Implementation Note:

此方法的实施相当于 doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)。

参数

randomNumberOrigin -起源（含）各随机值

randomNumberBound -束缚（独家）各随机值

结果

一个流的伪随机 double值，每个给定的起源（含）和绑定（独家）

异常

IllegalArgumentException -如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

一点八