- 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代码的绝对可移植性,Java实现必须使用这里所示的Random
类的所有算法。 但是,Random
类的子类允许使用其他算法,只要它们遵守所有方法的一般合同。Random
实现的算法使用protected
实用程序方法,每个调用可以提供多达32个伪随机生成的位。许多应用程序会发现方法
Math.random()
使用起来更简单。java.util.Random
实例是线程安全的。 但是,同时使用跨线程的java.util.Random
实例可能会遇到争用,从而导致性能下降。 在多线程设计中考虑使用ThreadLocalRandom
。java.util.Random
实例不是加密安全的。 考虑使用SecureRandom
获得一个加密安全的伪随机数生成器,供安全敏感应用程序使用。- 从以下版本开始:
- 1.0
- 另请参见:
- Serialized Form
-
-
方法摘要
所有方法 接口方法 具体的方法 Modifier and Type 方法 描述 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()
返回下一个伪,均匀分布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
种子设置此随机数生成器的种子。
-
-
-
构造方法详细信息
-
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))
.- 参数
-
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 32个可能的int
值以(近似)等概率产生。方法
nextInt
由类Random
实现,如:public int nextInt() { return next(32); }
- 结果
-
下一个伪随机数,从这个随机数发生器的序列中均匀分布
int
值
-
nextInt
public int nextInt(int bound)
返回伪随机数,从0(包括)和指定值(排除)之间均匀分布的int
值,从该随机数生成器的序列中抽取出来。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特别是2的幂的情况:它从底层伪随机数发生器返回正确数量的高阶位。 在没有特殊处理的情况下,将返回正确数量的低位 。 已知线性同余伪随机数发生器(例如由该类实现的)产生器在其低阶位的值序列中具有短周期。 因此,如果n是2的小功率,这种特殊情况大大增加了对该方法的连续调用返回的值的序列的长度。
- 参数
-
bound
- 上限(独占)。 必须是积极的。 - 结果
-
下一个伪随机数,从这个随机数发生器的序列中均匀分布在零(包括)和
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 ,其中m是小于2 24的正整数的所有2 24个可能的float
值。方法
nextFloat
由类Random
实现,好像通过如下:public float nextFloat() { return next(24) / ((float)(1 << 24)); }
仅在下面的方法仅仅是独立选择的位的无偏差源的情况下,在上述描述中使用了“大约”对冲。 如果它是随机选择位的完美源,则所示的算法将从所述范围中选择
float
值,具有完美的均匀性。[在Java的早期版本中,结果错误地计算为:
return next(30) / ((float)(1 << 30));
- 结果
-
下一个伪均匀分布
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);
- 结果
-
下一个伪均匀分布
double
值之间0.0
和1.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; } }
StrictMath.log
,另一个呼叫到StrictMath.sqrt
。- 结果
-
下一个伪随机数,高斯(“正常”)分布
double
值,平均值为0.0
,标准偏差为1.0
来自该随机数发生器的序列
-
ints
public IntStream ints(long streamSize)
- 参数
-
streamSize
- 要生成的值的数量 - 结果
-
一串伪随机数
int
- 异常
-
IllegalArgumentException
- 如果streamSize
小于零 - 从以下版本开始:
- 1.8
-
ints
public IntStream ints()
- Implementation Note:
-
该方法实现等同于
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; } }
- 参数
-
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; } }
- Implementation Note:
-
该方法实现相当于
ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
。 - 参数
-
randomNumberOrigin
- 每个随机值的起点(含) -
randomNumberBound
- 每个随机值的绑定(排他) - 结果
-
一个伪随机流,
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
,每个都有给定的来源(包括)和绑定(排他) - 异常
-
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; }
- Implementation Note:
-
该方法实现等同于
longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
。 - 参数
-
randomNumberOrigin
- 每个随机值的起点(含) -
randomNumberBound
- 每个随机值的绑定(排他) - 结果
-
一个伪随机数
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 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
- 从以下版本开始:
- 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; }
- Implementation Note:
-
该方法实现等同于
doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
。 - 参数
-
randomNumberOrigin
- 每个随机值的起始(含) -
randomNumberBound
- 每个随机值的绑定(排他) - 结果
-
一系列伪随机数(
double
,每个都有给定的来源(包括)和绑定(排他) - 异常
-
IllegalArgumentException
- 如果randomNumberOrigin
大于或等于randomNumberBound
- 从以下版本开始:
- 1.8
-
-