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]+",");
        }
    }
}

 方法三:相对有点不好理解,我加上了打印内容.方便理解.