//方式一：定義一個數組，每次隨機得到一個數字後，檢查數組中是否存在當前數字，不存在將其放入數組
    /**
     * 在指定數字範圍內，隨機獲取n個不重復數字
     * @param min 指定範圍最小值
     * @param max 指定範圍最大值
     * @param n    隨機獲取不重復數字個數
     * @return 隨機獲取n個不重復數字結果集
     */
    public static int[] randomNums(int min, int max, int n) {
        int range = max - min + 1;
        
 
//當下列情況任何一個成立時，返回null
        //①指定數字範圍的最小值大於最大值，
        //②需要隨機獲取的數字個數小於0，
        //③需要隨機獲取的數字個數大於指定數字範圍的數字個數
        if (min > max || n < 0 || n > range) {
            return null;
        }

        boolean isContainZero = false; //是否包含0
        boolean isGetZero = false; //是否隨機獲取到數字0
        //判斷指定範圍內是否包含0
 

        if (min <= 0 || max >= 0) {
            isContainZero = true;
        }

        int[] nums = new int[n];

        int count = 0;
        while (count < n) {
            int num = new Random().nextInt(range) + min;
            //當包含0時，且隨機獲取到第一個數字0時需要特殊處理
            if (isContainZero && !isGetZero && num == 0) {
                isGetZero 
 
= true;
                count++;
                continue;
            }

            boolean isExists = false; //標識隨機獲取到的數字在數組中是否已存在
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] == num) {
                    isExists = true;
                    break;
                }
            }
            //當隨機獲取到的數字在數組中不存在時，將數字放入數組中
            if (!isExists) {
                nums[count++] = num;
            }
        }
        return nums;
    }

//方式二：利用java中集合
    /**
     * 在指定數字範圍內，隨機獲取n個不重復數字
     * @param min 指定範圍最小值
     * @param max 指定範圍最大值
     * @param n    隨機獲取不重復數字個數
     * @return 隨機獲取n個不重復數字結果集
     */
    public static int[] randomNums2(int min, int max, int n) {
        int range = max - min + 1;
        //當下列情況任何一個成立時，返回null
        //①指定數字範圍的最小值大於最大值，
        //②需要隨機獲取的數字個數小於0，
        //③需要隨機獲取的數字個數大於指定數字範圍的數字個數
        if (min > max || n < 0 || n > range) {
            return null;
        }
        int[] nums = new int[n];
        List<Integer> list = new ArrayList<Integer>(n);
        while (list.size() < n) {
            int num = new Random().nextInt(range) + min;
            if (!list.contains(Integer.valueOf(num))) {
                nums[list.size()] = num;
                list.add(Integer.valueOf(num));
            }
        }

        return nums;
    }

    //方式三：定義一個源數組，將指定範圍數字放入源數組，隨機源數組的索引，每次隨機範圍減1，每次隨機到的索引元素值放入結果集數組中，
    //然後將隨機到的索引元素值替換為當前隨機的最大索引位置元素
    /**
     * 在指定數字範圍內，隨機獲取n個不重復數字
     * @param min 指定範圍最小值
     * @param max 指定範圍最大值
     * @param n    隨機獲取不重復數字個數
     * @return 隨機獲取n個不重復數字結果集
     */
    public static int[] randomNums3(int min, int max, int n) {
        int range = max - min + 1;
        //當下列情況任何一個成立時，返回null
        //①指定數字範圍的最小值大於最大值，
        //②需要隨機獲取的數字個數小於0，
        //③需要隨機獲取的數字個數大於指定數字範圍的數字個數
        if (min > max || n < 0 || n > range) {
            return null;
        }
        int[] nums = new int[n];
        int[] sources = new int[range];
        for (int i = 0; i < range; i++) {
            sources[i] = min + i;
        }

        for (int i = 0; i < n; i++) {
            int index = new Random().nextInt(range - i);
            nums[i] = sources[index];

            if (index != range - i - 1) {
                sources[index] = sources[range - i - 1];
            }
        }
        return nums;
    }

    //方式四：與方法三的思路類似，但不用存儲範圍內的數字
    /**
     * 在指定數字範圍內，隨機獲取n個不重復數字
     * @param min 指定範圍最小值
     * @param max 指定範圍最大值
     * @param n    隨機獲取不重復數字個數
     * @return 隨機獲取n個不重復數字結果集
     */
    public static int[] randomNums4(int min, int max, int n) {
        int range = max - min + 1;
        //當下列情況任何一個成立時，返回null
        //①指定數字範圍的最小值大於最大值，
        //②需要隨機獲取的數字個數小於0，
        //③需要隨機獲取的數字個數大於指定數字範圍的數字個數
        if (min > max || n < 0 || n > range) {
            return null;
        }

        int[] nums = new int[n];
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            Integer num = new Random().nextInt(range - i) + min;
            nums[i] = map.containsKey(num) ? map.get(num) : num.intValue();

            Integer j = Integer.valueOf(max - i);
            map.put(Integer.valueOf(num), map.containsKey(j) ? map.get(j) : j);
        }

        return nums;

    }

在指定數字範圍內，隨機獲取n個不重復數字