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 不是正数

*总结的的经典的回答:

https://*.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]+",");
         }
     }
 }

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