在Java中主要提供了两种方式产生随机数，分别为调用Math类的random()方法和Random类提供的产生各种数据类型随机数的方法。
 
1.Math.random()方法
 
这个方法默认生成大于等于0.0且小于1.0的double型随机数，即0<=Math.random()<1.0。
 
虽然Math.random()方法只可以产生0~1之间的double型数字，其实只要在Math.random()语句上稍加处理，就可以使用这个方法产生任意范围的随机数，如：
 
（int）(Math.random()*n)----->返回大于等于0且小于n的整数
 
  m+（int）(Math.random()*n)----->返回大于等于m且小于m+n（不包括m+n）的随机数
 
 
使用Math类的random()方法也可以随机生成字符，可以使用如下代码生成a~z之间的字符：
 
(char)('a'+Math.random()*('z'-'a'+1));      //加1是因为要取到z
 
 
2.Random类
 
（1）除了Math类中的random(）方法可以获取随机数之外，Java中还提供了一种可以获取随机数的方式，那就是java.util.Random类。可以通过实例化一个Random对象创建一个随机数生成器。
 
Random r=new Random();
 
以这种方式实例化对象时，Java编译器以系统当前时间作为随机数生成器的种子，因为每时每刻的时间不可能相同，所以产生的随机数将不同，但是如果运行速度太快，也会产生两次运行结果相同的随机数。
 
（2）同时也可以在实例化Random类对象时，设置随机数生成器的种子。
 
Random r=new Random（seedValue）；
 
在Random类中提供了获取各种数据类型随机数的方法，下面列举几个常用的方法：
 
        public int nextInt(): 返回一个随机整数
		public int nextInt(int n): 返回大于等于0且小于n的随机整数
		public long nextLong(): 返回一个随机长整型值
		public boolean nextBoolean(): 返回一个随机布尔型值
		public float nextFloat(): 返回一个随机浮点型值
		public double nextDouble(): 返回一个随机双精度型值
		public double nextGaussian(): 返回一个概率密度为高斯分布的双精度值
 

 
 

 
程序员的成长之路
 
互联网/程序员/技术/资料共享 
 

  
 
阅读本文大概需要 5.5 分钟。
 
作者：专职跑龙套
链接：https://www.jianshu.com/p/2f6acd169202
 
1. Math.random() 静态方法
 
产生的随机数是 0 - 1 之间的一个 double，即 0 <= random <= 1。
 
使用：
 
for (int i = 0; i < 10; i++) {
  System.out.println(Math.random());
}


 
结果：
 

  
0.3598613895606426 0.2666778145365811 0.25090731064243355 0.011064998061666276 0.600686228175639 0.9084006027629496 0.12700524654847833 0.6084605849069343 0.7290804782514261 0.9923831908303121
 
 
实现原理：
 

  
When this method is first called, it creates a single new pseudorandom-number generator, exactly as if by the expression new java.util.Random() This new pseudorandom-number generator is used thereafter for all calls to this method and is used nowhere else.
 
 
当第一次调用 Math.random() 方法时，自动创建了一个伪随机数生成器，实际上用的是 new java.util.Random()。当接下来继续调用 Math.random() 方法时，就会使用这个新的伪随机数生成器。
 
源码如下：
 
public static double random() {
    Random rnd = randomNumberGenerator;
    if (rnd == null) rnd = initRNG(); // 第一次调用，创建一个伪随机数生成器
    return rnd.nextDouble();
}

private static synchronized Random initRNG() {
    Random rnd = randomNumberGenerator;
    return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd; // 实际上用的是new java.util.Random()
}


 

  
This method is properly synchronized to allow correct use by more than one thread. However, if many threads need to generate pseudorandom numbers at a great rate, it may reduce contention for each thread to have its own pseudorandom-number generator.
 
 
initRNG() 方法是 synchronized 的，因此在多线程情况下，只有一个线程会负责创建伪随机数生成器（使用当前时间作为种子），其他线程则利用该伪随机数生成器产生随机数。
 
因此 Math.random() 方法是线程安全的。
 
什么情况下随机数的生成线程不安全：
 
线程1在第一次调用 random() 时产生一个生成器 generator1，使用当前时间作为种子。
线程2在第一次调用 random() 时产生一个生成器 generator2，使用当前时间作为种子。
碰巧 generator1 和 generator2 使用相同的种子，导致 generator1以后产生的随机数每次都和 generator2 以后产生的随机数相同。
 
什么情况下随机数的生成线程安全： Math.random() 静态方法使用
 
线程1在第一次调用 random() 时产生一个生成器 generator1，使用当前时间作为种子。
线程2在第一次调用 random() 时发现已经有一个生成器generator1，则直接使用生成器 generator1。
 
public class JavaRandom {
    public static void main(String args[]) {
        new MyThread().start();
        new MyThread().start();
    }
}
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + Math.random());
        }
    }
}


 
结果：
 

  
Thread-1: 0.8043581595645333 Thread-0: 0.9338269554390357 Thread-1: 0.5571569413128877 Thread-0: 0.37484586843392464
 
 
2. java.util.Random 工具类
 
基本算法：linear congruential pseudorandom number generator (LGC) 线性同余法伪随机数生成器缺点：可预测
 

  
An attacker will simply compute the seed from the output values observed. This takes significantly less time than 2^48 in the case of java.util.Random. 从输出中可以很容易计算出种子值。It is shown that you can predict future Random outputs observing only two(!) output values in time roughly 2^16. 因此可以预测出下一个输出的随机数。You should never use an LCG for security-critical purposes.在注重信息安全的应用中，不要使用 LCG 算法生成随机数，请使用 SecureRandom。
 
 
使用：
 
Random random = new Random();

for (int i = 0; i < 5; i++) {
    System.out.println(random.nextInt());
}


 
结果：
 

  
-24520987 -96094681 -952622427 300260419 1489256498
 
 
Random类默认使用当前系统时钟作为种子:
 
public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}

public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // subclass might have overriden setSeed
        this.seed = new AtomicLong();
        setSeed(seed);
    }
}


 
Random类提供的方法：API
 
nextBoolean() - 返回均匀分布的 true 或者 false
nextBytes(byte[] bytes)
nextDouble() - 返回 0.0 到 1.0 之间的均匀分布的 double
nextFloat() - 返回 0.0 到 1.0 之间的均匀分布的 float
nextGaussian()- 返回 0.0 到 1.0 之间的高斯分布（即正态分布）的 double
nextInt() - 返回均匀分布的 int
nextInt(int n) - 返回 0 到 n 之间的均匀分布的 int （包括 0，不包括 n）
nextLong() - 返回均匀分布的 long
setSeed(long seed) - 设置种子
 
只要种子一样，产生的随机数也一样： 因为种子确定，随机数算法也确定，因此输出是确定的！
 
Random random1 = new Random(10000);
Random random2 = new Random(10000);

for (int i = 0; i < 5; i++) {
    System.out.println(random1.nextInt() + " = " + random2.nextInt());
}


 
结果：
 

  
-498702880 = -498702880 -858606152 = -858606152 1942818232 = 1942818232 -1044940345 = -1044940345 1588429001 = 1588429001
 
 
3. java.util.concurrent.ThreadLocalRandom 工具类
 
ThreadLocalRandom 是 JDK 7 之后提供，也是继承至 java.util.Random。
 
private static final ThreadLocal<ThreadLocalRandom> localRandom =
    new ThreadLocal<ThreadLocalRandom>() {
        protected ThreadLocalRandom initialValue() {
            return new ThreadLocalRandom();
        }
};


 
每一个线程有一个独立的随机数生成器，用于并发产生随机数，能够解决多个线程发生的竞争争夺。效率更高！
 
ThreadLocalRandom 不是直接用 new 实例化，而是第一次使用其静态方法 current() 得到 ThreadLocal<ThreadLocalRandom> 实例，然后调用 java.util.Random 类提供的方法获得各种随机数。
 
使用：
 
public class JavaRandom {
    public static void main(String args[]) {
        new MyThread().start();
        new MyThread().start();
    }
}
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + ThreadLocalRandom.current().nextDouble());
        }
    }
}


 
结果：
 

  
Thread-0: 0.13267085355389086 Thread-1: 0.1138484950410098 Thread-0: 0.17187774671469858 Thread-1: 0.9305225910262372
 
 
4. java.Security.SecureRandom
 
也是继承至 java.util.Random。
 

  
Instances of java.util.Random are not cryptographically secure.Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.SecureRandom takes Random Data from your os (they can be interval between keystrokes etc - most os collect these data store them in files - /dev/random and /dev/urandom in case of linux/solaris) and uses that as the seed. 操作系统收集了一些随机事件，比如鼠标点击，键盘点击等等，SecureRandom 使用这些随机事件作为种子。
 
 
SecureRandom 提供加密的强随机数生成器 (RNG)，要求种子必须是不可预知的，产生非确定性输出。SecureRandom 也提供了与实现无关的算法，因此，调用方（应用程序代码）会请求特定的 RNG 算法并将它传回到该算法的 SecureRandom 对象中。
 
如果仅指定算法名称，如下所示：SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
如果既指定了算法名称又指定了包提供程序，如下所示：SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
 
使用：
 
SecureRandom random1 = SecureRandom.getInstance("SHA1PRNG");
SecureRandom random2 = SecureRandom.getInstance("SHA1PRNG");

for (int i = 0; i < 5; i++) {
    System.out.println(random1.nextInt() + " != " + random2.nextInt());
}


 
结果：
 

  
704046703 != 2117229935 60819811 != 107252259 425075610 != -295395347 682299589 != -1637998900 -1147654329 != 1418666937
 
 
5. 随机字符串
 
可以使用 Apache Commons-Lang 包中的 RandomStringUtils 类。Maven 依赖如下：
 
<dependency>
    <groupId>commons-lang</groupId>
    <artifactId>commons-lang</artifactId>
    <version>2.6</version>
</dependency>


 
API 参考：https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/RandomStringUtils.html
 
示例：
 
public class RandomStringDemo {
    public static void main(String[] args) {
        // Creates a 64 chars length random string of number.
        String result = RandomStringUtils.random(64, false, true);
        System.out.println("random = " + result);

        // Creates a 64 chars length of random alphabetic string.
        result = RandomStringUtils.randomAlphabetic(64);
        System.out.println("random = " + result);

        // Creates a 32 chars length of random ascii string.
        result = RandomStringUtils.randomAscii(32);
        System.out.println("random = " + result);

        // Creates a 32 chars length of string from the defined array of
        // characters including numeric and alphabetic characters.
        result = RandomStringUtils.random(32, 0, 20, true, true, "qw32rfHIJk9iQ8Ud7h0X".toCharArray());
        System.out.println("random = " + result);

    }
}


 
RandomStringUtils 类的实现上也是依赖了 java.util.Random 工具类：
 

 
RandomStringUtils 类的定义
 
<END>
 
推荐阅读：

 
27岁、47岁！国内两家知名企业同时传出员工猝死

 
超级全面的 SpringBoot 注解介绍，每一个用途都应该清晰

 
5T技术资源大放送！包括但不限于：C/C++，Linux，Python，Java，PHP，人工智能，单片机，树莓派，等等。在公众号内回复「2048」，即可免费获取！！
 

 
微信扫描二维码，关注我的公众号
 
朕已阅 
 

在实际开发工作中经常需要用到随机数。如有些系统中创建用户后会给用户一个随机的初始化密码。这个密码由于是随机的，为此往往只有用户自己知道。他们获取了这个随机密码之后，需要马上去系统中更改。这就是利用随机数的原理。总之随机数在日常开发工作中经常用到。而不同的开发语言产生随机数的方法以及技巧各不相同。笔者这里就以Java语言为例，谈谈随机数生成的方法以及一些技巧。
 
利用random方法来生成随机数。
 在Java语言中生成随机数相对来说比较简单，因为有一个现成的方法可以使用。在Math类中，Java语言提供了一个叫做random的方法。通过这个方法可以让系统产生随机数。不过默认情况下，其产生的随机数范围比较小，为大于等于0到小于1的double型随机数。虽然其随机数产生的范围比较小，不能够满足日常的需求。如日常工作中可能需要产生整数的随机数。其实，只要对这个方法进行一些灵活的处理，就可以获取任意范围的随机数。
 
如我们可以先通过random方法生成一个随机数，然后将结果乘以10。此时产生的随机数字即为大于等于0小于10的数字。然后再利用Int方法进行转换(它会去掉小数掉后面的数字，即只获取整数部分，不是四舍五入)。最后即可获取一个0到9的整数型随机数字。其实现方法很简单，就是对原有的random方法按照如下的格式进行变型：(int)(Math.Random()*10)即可。其实我们还可以对这个方法进行扩展，让其产生任意范围内的随机数。至需要将这个10换成n即可，如改为(int)(Math.Random()*n)。此时应用程序就会产生一个大于等于0小与n之间的随机数。如将n设置为5，那么其就会产生一个0到5之间的整数型的随机数。如果将这个写成一个带参数的方法，那么只要用户输入需要生成随机数的最大值，就可以让这个方法来生成制定范围的随机数。在Java中定义自己的工具库
 
有时候程序员可能需要生成一个指定范围内的随机偶数或者奇数。此时是否可以通过这个方法来实现呢?答案是肯定的。如现在程序要需要生成一个1-100范围内的偶数。此时该如何实现?首先，需要生成一个0到99之内的随机数(至于这里为什么是99，大家耐心看下去就知道原因了)。要实现这个需求，很简单吧，只要通过如下语句就可以实现：i=1+(int)(Math.Random()*100)。其中(int)(Math.Random()*99)产生0到99的整数型随机数。然后再加上1就是产生1到100之间的随机整数。然后将产生的随机数赋值给变量i。但是此时其产生的随机数即有偶数，又有奇数。而现在程序员需要的是一个随机的偶数。那么我们可以在后面加上一个if判断语句。将这个随机数除以2，如果没有余数的话(或者余数为0)则表明这个随机数是偶数，直接返回即可。如果其返回的余数不为零，那么就表明其是奇数，我们只要加上1就变为了偶数，返回即可。注意，在上面的随机数生成中，笔者采用的范围是0到99，然后再加上1让其变为1到100的随机数。最后的结果就是生成1到100之间的随机偶数。其实，如果要范围随机奇数的话，至需要对上面的语句进行稍微的修改即可。Java:改变你我的世界
 
假设现在用户想生成一个任意范围内的奇数或者偶数，能够实现吗?假设现在用户想实现一个m到n之间的任意偶数(其中m
 
可见虽然random方法其自身产生的随机数有比较严格的范围限制。但是只要对其进行合理的转换，程序员仍然可以采用这个方法产生用户所需要的随机数据。
 
通过Random类来生成随机数。
 
在Java语言中，除了可以通过random方法来产生随机数之外，还可以通过一个random类来产生随机数。程序开发人员可以通过实例化一个Random对象来创建一个随机数的生成器。如Random i=new Random()。通过这条语句就利用了Random类创建了一个随机数的生成器。不过以这种方法创建随机数时，与采用Random方法产生随机数的机制不同。利用现在这种方式实例化对象时，Java编译器会以系统当前的时间作为随机数生成器的种子。由于时间时时刻刻在变化的。若以这个时间作为生成器的种子，就可以保证生成的随机数真的是随机的，其生成的随机数重复率会大大的降低。
 
利用这种方法其比较方便。如可以利用提供的关键字，让程序返回一个随机的整数(采用int nextInt(10))等等。不过其返回控制要比Random方法困难一点。如现在需要系统提供一个10到50之间的随机奇数，利用这个Random类就无法完成。也就是说，利用这个Random类来生成随机数，其只能够控制上限，而不能够控制下限。换一句话说，其可以指定最大的随机数范围，而不能够指定最小的随机数范围。所以，在灵活性上，其比Random方法要稍微差一点。
 
另外利用这个方法来实现的话，必须先创建一个对象。也就是说利用Randow类来创建对象。这跟Randow方法不同。像上面举的例子中，Randow方法本身就是一个math类中方法，可以直接调用，省去对象创建的方法。为此笔者建议各位读者与程序开发人员，最好还是使用Random方法来创建随机数。只有在生成一些比较特殊的随机数时采用Random类。如现在需要生成一个概率密度为高斯分布的双精度值随机数时，则通过采用Random类的方法来创建随机数相对来说比较简单一点。
 
产生随机的字符。
 
上面介绍的两种方法，产生的都是随机的数值型数据。但是有时候用户可能还需要产生随机的字符。其实也可以利用random方法来产生随机字符。如可以利用代码生成一个随机的小写字符：(char)(‘a’+Math.random()*(‘z’-‘a’+1))。其实这跟生成任意两个数之间的随机数类似。通过以上的代码就可以生成一个范围之内的任意随机字符。通过对这个代码进行适当的修整，还可以生成任意两个字符之间的随机字符与任意大写字符的随机字符。其转换的方式跟上面提到的任意范围之内的随机数类似。各位读者若感兴趣的话，可以自己进行测试一下。师傅领进门，修行在自身。如果笔者在这里一股脑儿将所有的答案告诉大家，大家的印象不会很深。大家若回去自己动手试试看，反而更容易记住。
 
笔者在这里给大家一个提示，只需要根据m+(int)(Math.Random()(n-m))这条语句来调整(char)(‘a’+Math.random()(‘z’-‘a’+1))这个代码即可。
 
进阶
 
通过阅读Math.random()的源码，或者干脆利用IDE的自动完成功能，开发人员可以很容易发现，java.lang.Math.random()使用一个内部的随机生成对象-一个很强大的对象可以灵活的随机产生：布尔值、所有数字类型，甚至是高斯分布。例如：
 
new java.util.Random().nextInt(10)
 
它有一个缺点，就是它是一个对象。它的方法必须是通过一个实例来调用，这意味着必须先调用它的构造函数。如果在内存充足的情况下，像上面的表达式是可以接受的；但内存不足时，就会带来问题。
 
一个简单的解决方案，可以避免每次需要生成一个随机数时创建一个新实例，那就是使用一个静态类。猜你可能想到了java.lang.Math，很好，我们就是改良java.lang.Math的初始化。虽然这个工程量低，但你也要做一些简单的单元测试来确保其不会出错。
 
假设程序需要生成一个随机数来存储，问题就又来了。比如有时需要操作或保护种子(seed)，一个内部数用来存储状态和计算下一个随机数。在这些特殊情况下，共用随机生成对象是不合适的。
 
并发
 
在Java EE多线程应用程序的环境中，随机生成实例对象仍然可以被存储在类或其他实现类，作为一个静态属性。幸运的是，java.util.Random是线程安全的，所以不存在多个线程调用会破坏种子(seed)的风险。
 
另一个值得考虑的是多线程java.lang.ThreadLocal的实例。偷懒的做法是通过Java本身API实现单一实例，当然你也可以确保每一个线程都有自己的一个实例对象。
 
虽然Java没有提供一个很好的方法来管理java.util.Random的单一实例。但是，期待已久的Java 7提供了一种新的方式来产生随机数：
 
java.util.concurrent.ThreadLocalRandom.current().nextInt(10)
 
这个新的API综合了其他两种方法的优点：单一实例/静态访问，就像Math.random()一样灵活。ThreadLocalRandom也比其他任何处理高并发的方法要更快。
 
经验
 
Chris Marasti-Georg指出:
 
Math.round(Math.random() * 10)
 
使分布不平衡，例如：0.0-0.499999将四舍五入为0，而0.5至1.499999将四舍五入为1。那么如何使用旧式语法来实现正确的均衡分布，如下：
 
Math.floor(Math.random() * 11）
 
幸运的是，如果我们使用java.util.Random或java.util.concurrent.ThreadLocalRandom就不用担心上述问题了。
 
Java实战项目里面介绍了一些不正确使用java.util.Random API的危害。这个教训告诉我们不要使用：
 
Math.abs(rnd.nextInt())%n
 
而使用：
 
rnd.nextInt(n)

 
Java Random类的详细介绍（Java生成随机数）
 
一、Random类的使用
1.Random类生成随机数(int)的基本语法：
2.几种常用的随机数生成
  
二、Random类的详细介绍
1.生成指定范围的数字
2.Random.nextInt()与Math.random()的区别
 

 
 
一、Random类的使用
 
Random类的功能，生成一个随机数
 
1.Random类生成随机数(int)的基本语法：
 
(1)生成int取值范围的任意一个数
 
Random r = new Random();
int num = r.nextInt();
 
(2)生成指定范围的任意一个数
 
Random r = new Random();
int num = r.nextInt(n);
//参数 n 代表指定范围的数字[0,n)
 
2.几种常用的随机数生成
 
方法
参数
随机数取值范围
返回值类型
实例
nextBoolean()
无
true、false
boolean
1
nextDouble()
无
[0.0，1.0)
double
2
nextFloat()
无
[0.0，1.0)
float
3
nextInt()
无
int的取值范围
int
4
nextInt(int bound)
有
参数代表指定范围的数字[0，bound)
int
5
nextLong()
无
long取值范围
long
6
nextBytes(byte[] bytes)
有
生成byte.length个数字放入byte[]中
void
7
代码实例 - 1
 
//生成Boolean随机数
Random r = new Random();
boolean b = r.nextBoolean();
System.out.println("生成的Boolean随机数是:"+b);
 
代码实例 - 2
 
//生成double随机数
Random r = new Random();
double d = r.nextDouble();
System.out.println("生成的Double随机数是:"+d);
 
代码实例 - 3
 
//生成Float随机数
Random r = new Random();
double f = r.nextFloat();
System.out.println("生成的Float随机数是:"+f);
 
代码实例 - 4
 
//生成int随机数
Random r = new Random();
int i = r.nextInt();
System.out.println("生成的Int随机数是:"+i);
 
代码实例 - 5
 
//生成[0,5)int随机数
Random r = new Random();
int i = r.nextInt(5);
System.out.println("生成[0,5)的]Int随机数是:"+i);
 
代码实例 - 6
 
//生成Long随机数
Random r = new Random();
long l = r.nextLong();
System.out.println("生成的Long随机数是:"+l);
 
代码实例 - 7
 
//将随机数字放入数组中
Random r = new Random();
byte[] arr = new byte[5];
r.nextBytes(arr);
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]+",");
}
 
二、Random类的详细介绍
 
1.生成指定范围的数字
 
 
 
左闭右闭 [a,b]：r.nextInt(b-a+1)+a
 
 
Random r = new Random();
int a = 5;
int b = 10;
int res = r.nextInt(b-a+1)+a;
System.out.println(res);
 
 
 
 
左闭右开 [a,b)：r.nextInt(b-a)+a
 
 
Random r = new Random();
int a = 5;
int b = 10;
int res = r.nextInt(b-a)+a;
System.out.println(res);
 
 
 
 
左开右闭 (a,b]：r.nextInt(b-a)+a+1
 
 
Random r = new Random();
int a = 5;
int b = 10;
int res = r.nextInt(b-a)+a+1;
System.out.println(res);
 
 
 
 
左开右开 (a,b)：r.nextInt(b-a-1)+a+1
 
 
Random r = new Random();
int a = 5;
int b = 10;
int res = r.nextInt(b-a-1)+a+1;
System.out.println(res);
 
 
2.Random.nextInt()与Math.random()的区别
 
(1)来源
 
 
 
random.nextInt() 为 java.util.Random类中的方法；
Math.random() 为 java.lang.Math 类中的静态方法。
 
 
(2)用法
 生成[0,n)的随机数
 
//Random.nextInt()
Random r = new Random();
int r = random.nextInt(n);
 
//Math.random()
int res = (int)(Math.random() * n);
 
(3)总结
 
 
 
Math.random() 方法生成[0, 1)范围内的double类型随机数；Random类中的nextXxxx系列方法生成0－n的随机数；
Math.random() 线程安全，多线程环境能被调用；
如无特殊需求，则使用(int)(Math.random()*n)的方式生成随机数即可。
 
 
 
 
 
csdn - random.nextInt与Math.random基础用法 ↩︎ ↩︎ ↩︎