java中的random函数

java中存在两种Random函数：

1.java.lang.Math.Random

2.java.util.Random

下面先介绍一下第一种：

调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

public class random {
    /*演示lang包中的random函数*/
	public static void main(String[] args) {
	   for(int i=0;i<10;i++){
	   int rand=(int)(Math.random()*10)+1;
	   System.out.print(rand+" ");
	   }
	}
}

第二种java.util.Random

Random()的两种构造方法：

　　　　 Random()：创建一个新的随机数生成器。

　　　　 Random(long seed)：使用单个 long 种子创建一个新的随机数生成器。在构造Random对象的时候指定种子，

             如：Random r1 = new Random(100);

             默认当前系统时间的毫秒数作为种子数:Random r1 = new Random();

          

       Random rand=new Random(666);
       int i=rand.nextInt(1000)+1; 

rand.nextInt(1000);中的1000是随机数的上限,产生的随机数为0-1000的整数,不包括1000，于是后面加1。

             

import java.util.ArrayList;  
import java.util.Random;  
  
public class TestRandom {  
      
    public static void main(String[] args) {  
          
        // 案例2  
        // 对于种子相同的Random对象，生成的随机数序列是一样的。  
        Random ran1 = new Random(10);  
        System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");  
        for (int i = 0; i < 10; i++) {  
            System.out.print(ran1.nextInt(10) + " ");  
        }  
        System.out.println();  
        Random ran2 = new Random(10);  
        System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");  
        for (int i = 0; i < 10; i++) {  
            System.out.print(ran2.nextInt(10) + " ");  
        }  
        /** 
         * 输出结果为： 
         *  
         * 使用种子为10的Random对象生成[0,10)内随机整数序列:  
         * 3 0 3 0 6 6 7 8 1 4  
         * 使用另一个种子为10的Random对象生成[0,10)内随机整数序列:  
         * 3 0 3 0 6 6 7 8 1 4  
         *  
         */  
          
        // 案例3  
        // 在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。  
        Random r3 = new Random();  
        System.out.println();  
        System.out.println("使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列");  
        for (int i = 0; i < 10; i++) {  
            System.out.print(r3.nextInt(10)+" ");  
        }  
        /** 
         * 输出结果为： 
         *  
         * 使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列 
         * 1 1 0 4 4 2 3 8 8 4 
         *   
         */  
          
        // 另外，直接使用Random无法避免生成重复的数字，如果需要生成不重复的随机数序列，需要借助数组和集合类  
        ArrayList list=new TestRandom().getDiffNO(10);  
        System.out.println();  
        System.out.println("产生的n个不同的随机数："+list);  
    }  
      
    /** 
     * 生成n个不同的随机数，且随机数区间为[0,10) 
     * @param n 
     * @return 
     */  
    public ArrayList getDiffNO(int n){  
        // 生成 [0-n) 个不重复的随机数  
        // list 用来保存这些随机数  
        ArrayList list = new ArrayList();  
        Random rand = new Random();  
        boolean[] bool = new boolean[n];  
        int num = 0;  
        for (int i = 0; i < n; i++) {  
            do {  
                // 如果产生的数相同继续循环  
                num = rand.nextInt(n);  
            } while (bool[num]);  
            bool[num] = true;  
            list.add(num);  
        }  
        return list;  
    }  
      
      
}  

以下是api中的一些Java.util.Random()方法：

1. protected int next(int bits)：生成下一个伪随机数。
2. boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。
3. void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。
4. double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
5. float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
6. double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。
7. int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
8. int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。
9. long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
10. void setSeed(long seed)：使用单个 long 种子设置此随机数生成器的种子。

下面给几个例子：

1. 生成[0,1.0)区间的小数：double d1 = r.nextDouble();
2. 生成[0,5.0)区间的小数：double d2 = r.nextDouble() * 5;
3. 生成[1,2.5)区间的小数：double d3 = r.nextDouble() * 1.5 + 1;
4. 生成-231到231-1之间的整数：int n = r.nextInt();
5. 生成[0,10)区间的整数：

　　　　int n2 = r.nextInt(10);//方法一

　　　　n2 = Math.abs(r.nextInt() % 10);//方法二