Java獲取隨機數獲取制定范圍指定個數不重復的隨機數

一.JDK中提供的兩種方式

1.Math類中的random()方法
public static double random()
返回帶正號的 double 值，該值大於等於 0.0 且小於 1.0 [0.0,1.0)。返回值是一個偽隨機選擇的數，在該范圍內（近似）均勻分布。

2.Random類中的 nextInt()方法
public int nextInt()
返回一個隨機數,所有 2的32次方個可能 int 值的生成概率（大致）相同。

public int nextInt(int n)
返回一個偽隨機數，它是取自此隨機數生成器序列的、在 0（包括）和指定值（不包括）之間均勻分布的 int 值。
nextInt 的常規協定是，偽隨機地生成並返回指定范圍中的一個 int 值。所有可能的 n 個 int 值的生成概率（大致）相同。

參數：
n - 要返回的隨機數的范圍。必須為正數。
返回：
隨機數生成器序列中 0（包括）和 n（不包括）之間  [0,n) 均勻分布的 int 值。
拋出：
IllegalArgumentException - 如果 n 不是正數

StackOverFlow總結的的經典的回答:

https://stackoverflow.com/questions/363681/how-do-i-generate-random-integers-within-a-specific-range-in-java

二.隨機獲取制定范圍的制定個數的隨機數

上代碼:

import java.util.HashSet;
import java.util.Random;

public class GenerateRandomNumber {
    
    public static void main(String[] args) {
        //一、JAVA中生成隨機數的方式
        //①
        //int randomNumber = (int) Math.round(Math.random()*(max-min)+min); 
        
        //②
        //long randomNum = System.currentTimeMillis();  
        //int randomNumber = (int) randomNum%(max-min)+min; 
        
        //③
        //Random random = new Random();  
        //int randomNumber =  random.nextInt(max)%(max-min+1) + min;        

//方法一：最簡單最易理解的兩重循環去重  
//        int[] reult1 = randomCommon(20, 50, 10);
//        for (int i : reult1) {
//            System.out.println(i);
//        }

//方法二：利用HashSet的特征，只能存放不同的值  
//        HashSet<Integer> set = new HashSet<Integer>();
//        randomSet(20, 50, 10, set);
//        for (int j : set) {
//            System.out.println(j);
//        }

//方法三：排除已隨機到的數  
      int[] reult2 = randomArray(0, 20, 18);
//      for (int i : reult2) {
//          System.out.println(i);
//      }        
}      
    
    //二、隨機給定范圍內N個不重復的數
    /** 
     * 方法一：最簡單最易理解的兩重循環去重  
     * 隨機指定范圍內N個不重復的數 
     * 最簡單最基本的方法 
     * @param min 指定范圍最小值 
     * @param max 指定范圍最大值 
     * @param n 隨機數個數 
     */  
    public static int[] randomCommon(int min, int max, int n){  
        if (n > (max - min + 1) || max < min) {  
               return null;  
           }  
        int[] result = new int[n];  
        int count = 0;  
        while(count < n) {  
            int num = (int) (Math.random() * (max - min)) + min;  
            boolean flag = true;  
            for (int j = 0; j < n; j++) {  
                if(num == result[j]){
                    flag = false;  
                    break;  
                }  
            }  
            if(flag){  
                result[count] = num;  
                count++;  
            }  
        }  
        return result;  
    }  
    
    /** 
     * 方法二：利用HashSet的特征，只能存放不同的值  
     * 隨機指定范圍內N個不重復的數 
     * 利用HashSet的特征，只能存放不同的值 
     * @param min 指定范圍最小值 
     * @param max 指定范圍最大值 
     * @param n 隨機數個數 
     * @param HashSet<Integer> set 隨機數結果集 
     */  
       public static void randomSet(int min, int max, int n, HashSet<Integer> set) {  
           if (n > (max - min + 1) || max < min) {  
               return;  
           }  
           for (int i = 0; i < n; i++) {  
               // 調用Math.random()方法  
               int num = (int) (Math.random() * (max - min)) + min;  
               set.add(num);// 將不同的數存入HashSet中  
           }  
           int setSize = set.size();  
           // 如果存入的數小於指定生成的個數，則調用遞歸再生成剩余個數的隨機數，如此循環，直到達到指定大小  
           if (setSize < n) {  
            randomSet(min, max, n - setSize, set);// 遞歸  
           }  
       }  
       
    /** 
     * 方法三：排除已隨機到的數  
     * 隨機指定范圍內N個不重復的數 
     * 在初始化的無重復待選數組中隨機產生一個數放入結果中， 
     * 將待選數組被隨機到的數，用待選數組(len-1)下標對應的數替換 
     * 然后從len-2里隨機產生下一個隨機數，如此類推 
     * @param max  指定范圍最大值 
     * @param min  指定范圍最小值 
     * @param n  隨機數個數 
     * @return int[] 隨機數結果集 
     */  
    public static int[] randomArray(int min,int max,int n){
        //min=20 max=40 n=10 
        int len = max-min+1;  
          
        if(max < min || n > len){  
            return null;  
        }  
          
        //初始化給定范圍的待選數組  
        int[] source = new int[len];  
           for (int i = min; i < min+len; i++){  
            source[i-min] = i;  
           }
           //source 初始化之后就是min~max(包括首尾) 之間的所有數字的一個數組.[20,21...,10]
             
           int[] result = new int[n];  
           Random random = new Random();  
           int index = 0;  
           for (int i = 0; i < result.length; i++) {  
               System.out.println("第"+i+"次循環");
               
               int randomInt = random.nextInt();
               int maxEffectiveArraySubScript = len--;//最大有效數組下標,數組中超過這個下標的值都沒有用了...
               //待選數組0到(len-2)隨機一個下標    除數(maxEffectiveArraySubScript) 取余 范圍為(0~maxEffectiveArraySubScript-1)
               //即(0~maxEffectiveArraySubScript-1) <==> 0到(len-2)
               index = Math.abs(randomInt % maxEffectiveArraySubScript ); 
               
               System.out.println("randomInt:"+randomInt+",原數組最大有效角標:"+maxEffectiveArraySubScript+",index:"+index);
               System.out.println("原數組有效檢索子數組:");
               printArray(source,maxEffectiveArraySubScript);
               System.out.println("");
               
               //將隨機到的數放入結果集  
               result[i] = source[index];
               System.out.println("找到的數為:"+result[i]);
               //將待選數組中被隨機到的數，用待選數組(len-1)下標對應的數替換 ,這樣確保"有效檢索子數組"中后面沒有檢索到的數據前移,下一次仍可能隨機找到.
               //因為每一次循環 原數組的有效長度都是-1的...
               source[index] = source[len];
               
               System.out.println("原數組變成:");
               printArray(source);
               System.out.println("");
               System.out.println("目標數組為:");
               printArray(result);
               System.out.println("");
           }  
           return result;  
    }
    
    public static void printArray(int []  intArray){
        for (int i = 0; i < intArray.length; i++) {
            System.out.print(intArray[i]+",");
        }
    }
    
    public static void printArray(int []  intArray,int maxArrayNum){
        for (int i = 0; i < maxArrayNum; i++) {
            System.out.print(intArray[i]+",");
        }
    }
}

 

 

 方法三:相對有點不好理解,我加上了打印內容.方便理解.