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 ，并且对每个实例进行相同的方法调用序列，则它们将生成并返回相同的数字序列。 为了保证此属性，为Random类Random 。 为了Java代码的绝对可移植性，Java实现必须使用这里所示的所有算法为Random类。 然而，Random类的子类Random使用其他算法，只要它们遵守所有方法的一般合同。

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

许多应用程序会发现方法Math.random()使用起来更简单。

java.util.Random的java.util.Random是线程安全的。 但是，跨线程的同时使用java.util.Random实例可能会遇到争用，从而导致性能下降。 在多线程设计中考虑使用ThreadLocalRandom 。

java.util.Random的java.util.Random不是加密安全的。 考虑使用SecureRandom获取一个加密安全的伪随机数生成器，供安全敏感应用程序使用。

从以下版本开始：

1.0

另请参见：

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值 double ，每个值都符合给定的起始（包括）和绑定（排他）。
DoubleStream	doubles(long streamSize) 返回一个流，产生给定的 streamSize伪 double数值 double ，每个值在零（包括）和一（独占）之间。
DoubleStream	doubles(long streamSize, double randomNumberOrigin, double randomNumberBound) 返回一个流，产生给定的 streamSize伪 double数值 double ，每个值符合给定的起始（包括）和绑定（排他）。
IntStream	ints() 返回一个有效的无限流的伪 int值。
IntStream	ints(int randomNumberOrigin, int randomNumberBound) 返回一个有效的无限流伪 int值 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值 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值 0.0分布。
float	nextFloat() 返回下一个伪随机数，从这个随机数发生器的序列中 0.0和 1.0之间的 float值 0.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

构造方法详细信息

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使用的标志nextGaussian() 。

实施setSeed由类Random碰巧只使用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在“计算机编程艺术 ”第3卷： Seminumerical Algorithms ，第3.2.1节中描述。

参数

bits - 随机位

结果

来自该随机数发生器序列的下一个伪随机值

从以下版本开始：

1.1

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 - 如果字节数组为空

从以下版本开始：

1.1

nextInt

public int nextInt()

返回下一个伪随机数，从这个随机数生成器的序列中均匀分布int值。 nextInt的一般合同是一个int值被伪随机生成并返回。 所有2 ³²可能的int值以（大约）相等的概率产生。

方法nextInt由Random类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将从所述范围中选择int值，具有完美的均匀性。

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

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

参数

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

结果

下一个伪随机数，从这个随机数发生器的序列中均匀 int到零（包括）和 bound （排他）之间的值int

异常

IllegalArgumentException - 如果绑定 IllegalArgumentException

从以下版本开始：

1.2

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值

从以下版本开始：

1.2

nextFloat

public float nextFloat()

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

nextFloat的一般合同是一个float值，从0.0f （含）到1.0f （独占）一起选择（大致）均匀，被伪随机生成并返回。 以（大致）等概率产生形式m× 2 ^-24的全部2 ^24个可能的float值，其中m是小于2 ²⁴的正整数。

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

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

仅在下面的方法仅仅是独立选择的位的无偏差源时才使用“近似”对冲。 如果它是随机选择位的完美来源，则所示的float将从所述范围中选择float值，具有完美的均匀性。

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

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

这可能似乎是等同的，如果不是更好，但实际上它引入了一个轻微的不均匀性，因为浮点数的四舍五入的偏差：有意义的低位比较有可能是0这将是1.]

结果

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

nextDouble

public 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方法只是大致上独立选择的位的无偏差源，所以在next的描述中使用了“大约”对冲。 如果它是随机选择的位的完美来源，则所示的double将从所述范围中选择double值，具有完美的均匀性。

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

   return (((long)next(27) << 27) + next(27)) / (double)(1L << 54); 

这可能似乎是等同的，如果不是更好，但事实上它引入了一个大的不均匀性，因为浮点数的四舍五入有偏差：有效位的低位是0的可能性是三倍比那会是1！ 这种不均匀性在实践中可能无关紧要，但我们力求完美。]

结果

下一个伪随机数，从这个随机数发生器的序列中 0.0和 1.0之间的 double值 0.0分布

另请参见：

Math.random()

nextGaussian

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

这使用GEP Box，ME 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)

返回一个流，产生给定的streamSize数量的伪int数int值。

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

参数

streamSize - 要生成的值的数量

结果

一串 int值

异常

IllegalArgumentException - 如果 streamSize小于零

从以下版本开始：

1.8

ints

public IntStream ints()

返回一个有效的无限流的伪int值。

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

Implementation Note:

该方法实现等同于 ints(Long.MAX_VALUE) 。

结果

一串 int值

从以下版本开始：

1.8

ints

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

返回一个流，产生给定的streamSize伪int数值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; } } 

参数

streamSize - 要生成的值的数量

randomNumberOrigin - 每个随机值的起始（含）

randomNumberBound - 每个随机值的绑定（排他）

结果

一个伪 int的流量 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; } } 

Implementation Note:

该方法被实现为等同于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。

参数

randomNumberOrigin - 每个随机值的起点（含）

randomNumberBound - 每个随机值的绑定（排他）

结果

一个伪 int流（int），每个都有给定的来源（包括）和绑定（排他）

异常

IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

1.8

longs

public LongStream longs(long streamSize)

返回一个流，产生给定的streamSize数long数值。

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

参数

streamSize - 要生成的值的数量

结果

一串 long值

异常

IllegalArgumentException - 如果 streamSize小于零

从以下版本开始：

1.8

longs

public LongStream longs()

返回一个有效的无限流的伪long值。

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

Implementation Note:

该方法实现等于 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; } 

参数

streamSize - 要生成的值的数量

randomNumberOrigin - 每个随机值的起点（含）

randomNumberBound - 每个随机值的绑定（排他）

结果

一个伪 long流long，每个都有给定的来源（包括）和绑定（排他）

异常

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

从以下版本开始：

1.8

longs

public LongStream longs(long randomNumberOrigin,
                        long randomNumberBound)

返回一个有效的无限流伪long值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流（long），每个都有给定的来源（包括）和绑定（排他）

异常

IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

1.8

doubles

public DoubleStream doubles(long streamSize)

返回一个流，产生给定的streamSize数double值，每个值在零（包括）和一（独占）之间。

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

参数

streamSize - 要生成的值的数量

结果

double值

异常

IllegalArgumentException - 如果 streamSize小于零

从以下版本开始：

1.8

doubles

public DoubleStream doubles()

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

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

Implementation Note:

该方法实现等同于 doubles(Long.MAX_VALUE) 。

结果

一串 double值

从以下版本开始：

1.8

doubles

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

返回一个流，产生给定的streamSize伪double数值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; } 

参数

streamSize - 要生成的值的数量

randomNumberOrigin - 每个随机值的起始（含）

randomNumberBound - 每个随机值的绑定（排他）

结果

一个伪 double流（double），每个都有给定的来源（包括）和绑定（排他）

异常

IllegalArgumentException - 如果 streamSize小于零

IllegalArgumentException - 如果 randomNumberOrigin大于等于 randomNumberBound

从以下版本开始：

1.8

doubles

public DoubleStream doubles(double randomNumberOrigin,
                            double randomNumberBound)

返回一个有效的无限流伪double值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流double，每个都有给定的起源（包括）和绑定（独占）

异常

IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound

从以下版本开始：

1.8