【JavaSE API 】生成随机数的2种方法：Random类和Math类的Random方法

生成随机数的两种方法

Random类和Math类的random方法都可以用来生成随机数

• 而Math类的random方法则是基于系统时间的伪随机数生成器，>= 0.0 , <1.0的随机double值范围[0,1)。例如： double num1 = Math.random() * 5 + 4;//范围[4,9)
• Random类是基于种子的伪随机数生成器，有含参数和不含参数两种构造方式，不含参数的构造方法每次都使用当前系统时间作为种子，而含餐构造是使用一个固定值（参数n）作为种子范围[0,n)。
  例如：

Random rd1 = new Random();
double num2 = rd1.nextDouble();
 
Random rd2 = new Random(10);
double num3 = rd2.nextDouble();
1
2
3
4
5

1. Math.random() 无参调用，返回值为 double，大于等于 0.0 ，小于 1.0。范围[0.0,1.0)

static double random​() 返回值为 double的正值，大于等于 0.0 ，小于 1.0 。

double randomDouble = Math.random(); // 生成[0,1)之间的随机小数
int randomNumber = (int) (2 + Math.random() * 101); // 生成[2,103)之间的随机整数
1
2

2. Random类对象的next()方法，可有参。从这个随机数生成器的序列返回下一个伪随机数，均匀分布的 int值。

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

1
2
3
4
5
6
7
8
9
10

 public static void main(String[] args) {
        //测试一下生成随机数的两种方法
        int i = 0;
        for (i = 0; i < 10000; i++) {
            System.out.println("=====================================");
            double numDouble1 = Math.random();
            int numInt1 = (int)(Math.random()*(10));
            System.out.println("Math.random的随机浮点数[0.0,1.0)：" + numDouble1);
            System.out.println("Math.random的随机整数[0,9]" + numInt1);
            System.out.println("---------------------------------------");

            Random rd = new Random();
            double numDouble2 = rd.nextDouble();
            int numInt2 = rd.nextInt();
            int numInt3 = rd.nextInt();

            int numInt4 = rd.nextInt(4);
            int numInt5 = rd.nextInt(4);
            System.out.println("Random对象的无参随机浮点数[0.0,1.0]：" + numDouble2);//不知道边界情况，没人说过，只说之间。不管了，反正都用Math类
            System.out.println("Random对象的无参随机整数[-整数，整数]："  + numInt2 + "," + numInt3);
            System.out.println("Random对象的参数构造[0,4)：" + numInt5 + "," + numInt4);
            
            System.out.println("--------------------------------------");
            Random rd1 = new Random(10);
            double numDouble3 = rd1.nextDouble();
            
            Random rd2 = new Random(10);
            double numDouble4 = rd2.nextDouble();
            int numInt6 = rd2.nextInt(5);
            
            System.out.println("参数10的Random对象生成的随机浮点数" + numDouble3 + "," + numDouble4);
            // ● 错误点，因为种子相同，所以生成的数也相同
            System.out.println("参数10的Random对象生成的随机整数[0,5):" + numInt6 );
            // ● 错误点，永远生成一样的数

        }
        System.out.println("执行" + i + "次");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

其中三次运行结果
注意到参数10的Random对象生成的数每次都一样：

参数10的Random对象生成的随机浮点数：0.7304302967434272,0.7304302967434272
参数10的Random对象生成的随机整数[0,5):3

=====================================
Math.random的随机浮点数[0.0,1.0)：0.7142916697602802
Math.random的随机整数[0,9]：6
---------------------------------------
Random对象的无参随机浮点数[0.0,1.0]：0.6315568322991557
Random对象的无参随机整数[-整数，整数]：73848388,929911462
Random对象的参数构造[0,4)：0,0
--------------------------------------
参数10的Random对象生成的随机浮点数：0.7304302967434272,0.7304302967434272
参数10的Random对象生成的随机整数[0,5):3
=====================================
Math.random的随机浮点数[0.0,1.0)：0.6622105346737387
Math.random的随机整数[0,9]：4
---------------------------------------
Random对象的无参随机浮点数[0.0,1.0]：0.7790519044760864
Random对象的无参随机整数[-整数，整数]：-1185189383,-718067040
Random对象的参数构造[0,4)：2,2
--------------------------------------
参数10的Random对象生成的随机浮点数：0.7304302967434272,0.7304302967434272
参数10的Random对象生成的随机整数[0,5):3
=====================================
Math.random的随机浮点数[0.0,1.0)：0.4240920821616745
Math.random的随机整数[0,9]：8
---------------------------------------
Random对象的无参随机浮点数[0.0,1.0]：0.36926846454559725
Random对象的无参随机整数[-整数，整数]：1829129943,120476504
Random对象的参数构造[0,4)：2,0
--------------------------------------
参数10的Random对象生成的随机浮点数：0.7304302967434272,0.7304302967434272
参数10的Random对象生成的随机整数[0,5):3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注意问题：Random有参构造后，调用方法生成随机数，数完全相同

只要Random构造的参数固定，生成的随机数也固定，完全不随机。不推荐使用

总结：
1.Math.random方法明确范围[0,1)
2.Random类无参构造时，无参调用方法生成随机数都为该类型数的范围，但如double为0.0~1.0之间但不清楚边界包含情况。
3.Random类的 nextInt​(int bound) 返回伪随机的，范围 [0,bound）。
4.Random类有参构造时，若参数相同，不管有参还是无参调用方法得到的数都相同，所以不可用常量参数构造Random，无法生成随机数如

			Random rd2 = new Random(10);
            double numDouble4 = rd2.nextDouble();//循环多少次都固定产生0.7304302967434272
            int numInt6 = rd2.nextInt(5);//固定产生3
1
2
3