在指定数字范围内，随机获取n个不重复数字

    //方式一：定义一个数组，每次随机得到一个数字后，检查数组中是否存在当前数字，不存在将其放入数组
    /**
     * 在指定数字范围内，随机获取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;

    }