实现的所有接口

Serializable

已知直接子类：

SecureRandom ， ThreadLocalRandom
```
public class Randomextends Objectimplements 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

构造方法摘要

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

方法摘要

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

声明方法的类 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() 。
    类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在The Computer of Computer Programming， Volume 2： Seminumerical Algorithms ，section 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 ^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 - 上限（不包括）。必须是积极的。
    
    结果
    
    下一个伪均匀分布 int之间的值零（含）及 bound （不含）从该随机数生成器的序列
    
    异常
    
    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()
```
    返回下一个伪随机数，从该随机数生成器的序列中均匀分布在0.0和1.0之间的float值。
    nextFloat的总合同是伪随机生成并返回的一个float值，从（范围0.0f （含））到1.0f （不包括）范围内均匀地选择（大约）。形式为m× 2 ^-24的所有2 ^24个可能的float值（其中m是小于2 ²⁴的正整数）以（近似）相等的概率产生。
    
    方法nextFloat由类Random实现，如同：
    
    public float nextFloat() { return next(24) / ((float)(1 << 24)); }
    
    在前面的描述中使用套期“近似”仅仅因为下一个方法仅是大致独立选择的比特的无偏源。如果它是随机选择位的完美来源，则所示算法将从所述范围中选择具有完美均匀性的float值。
    
    [在Java的早期版本中，结果被错误地计算为：
    
    return next(30) / ((float)(1 << 30));
    这似乎是等效的，如果不是更好的话，但实际上它引入了一个轻微的不均匀性，因为浮点数的舍入偏差：有效数的低位比0更可能是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方法仅是大致独立选择的比特的无偏源。如果它是随机选择位的完美来源，则所示算法将从所述范围中选择具有完美均匀性的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值，该值选自（大约）通常的正态分布，平均值为0.0 ，标准差为1.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; } }
    这使用了GEP Box，ME Muller和G. Marsaglia的极性方法 ，如Donald E. Knuth在“计算机程序设计的艺术”第2卷： 分子数算法 ，第3.4.1节，C小节，算法P中所描述的那样。它生成两个独立的值，只需要一次调用StrictMath.log和一次调用StrictMath.sqrt 。
    结果
    
    下一个伪随机数，高斯（“正常”）分布 double值，平均值为 0.0 ，标准差为 1.0来自此随机数生成器的序列
  - ints
```
public IntStream ints(long streamSize)
```
    返回生成给定streamSize个伪随机数int值的流。
    生成伪随机数int值，就好像它是调用方法nextInt()的结果一样。
    
    参数
    
    streamSize - 要生成的值的数量
    
    结果
    
    伪随机 int值的流
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零
    
    从以下版本开始：
    
    1.8
  - ints
```
public IntStream ints()
```
    返回有效无限的伪随机int值流。
    生成伪随机数int值，就好像它是调用方法nextInt()的结果一样。
    
    Implementation Note:
    
    实现此方法等同于 ints(Long.MAX_VALUE) 。
    
    结果
    
    伪随机 int流 int
    
    从以下版本开始：
    
    1.8
  - ints
```
public IntStream ints(long streamSize,                      int randomNumberOrigin,                      int randomNumberBound)
```
    返回产生给定streamSize个伪随机数int值的流，每个值符合给定的原点（包括）和bound（不包括）。
    生成伪随机数int值，就好像它是使用origin和bound调用以下方法的结果：
    
    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值，就好像它是使用origin和bound调用以下方法的结果：
    
    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 。
    生成伪随机数long值，就好像它是调用方法nextLong()的结果一样。
    
    Implementation Note:
    
    实现此方法等同于 longs(Long.MAX_VALUE) 。
    
    结果
    
    伪随机 long值的流
    
    从以下版本开始：
    
    1.8
  - longs
```
public LongStream longs(long streamSize,                        long randomNumberOrigin,                        long randomNumberBound)
```
    返回产生给定streamSize个伪随机数streamSize的流，每个伪long都符合给定的原点（包括）和bound（不包括）。
    生成伪随机数long值，就好像它是使用origin和bound调用以下方法的结果：
    
    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 ，就好像它是使用origin和bound调用以下方法的结果：
    
    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 ，每个值在零（包括）和一（不包括）之间。
    生成伪随机数double值，就好像它是调用方法nextDouble()的结果一样。
    
    Implementation Note:
    
    实现此方法等同于 doubles(Long.MAX_VALUE) 。
    
    结果
    
    伪随机 double流 double
    
    从以下版本开始：
    
    1.8
  - doubles
```
public DoubleStream doubles(long streamSize,                            double randomNumberOrigin,                            double randomNumberBound)
```
    返回产生给定streamSize个伪随机数double值的流，每个值符合给定原点（包括）和绑定（不包括）。
    生成伪随机数double值，就好像它是使用origin和bound调用以下方法的结果：
    
    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值，就好像它是使用origin和bound调用以下方法的结果：
    
    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

Class Random

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

构造方法详细信息

Random

Random

方法详细信息

setSeed

next

nextBytes

nextInt

nextInt

nextLong

nextBoolean

nextFloat

nextDouble

nextGaussian

ints

ints

ints

ints

longs

longs

longs

longs

doubles

doubles

doubles

doubles