生成不重复随机数的算法

一：

 import java.util.Arrays;  

    import java.util.Random;  
      
    public class RandomNumber {  
      
        /**
         * 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
         * @param begin 最小数字（包含该数）
         * @param end 最大数字（不包含该数）
         * @param size 指定产生随机数的个数
         */  
        public static int[] generateRandomNumber(int begin, int end, int size) {  
            // 加入逻辑判断，确保begin<end并且size不能大于该表示范围  
            if (begin >= end || (end - begin) < size) {  
                return null;  
            }         
            // 种子你可以随意生成，但不能重复  
            int[] seed = new int[end - begin];   
          
            for (int i = begin; i < end; i ++) {  
                seed[i - begin] = i;  
            }  
            int[] ranArr = new int[size];  
            Random ran = new Random();  
            // 数量你可以自己定义。  
            for (int i = 0; i < size; i++) {  
                // 得到一个位置  
                int j = ran.nextInt(seed.length - i);             
                // 得到那个位置的数值  
                ranArr[i] = seed[j];  
                // 将最后一个未用的数字放到这里  
                seed[j] = seed[seed.length - 1 - i];  
            }  
            return ranArr;  
        }  
      
        public static void main(String[] args) {  
            int[] ranArr = generateRandomNumber(0,100,10);  
            System.out.println(Arrays.toString(ranArr));  
        }  
      

    } 

二：使用SET集合

    import java.util.Arrays;  
    import java.util.HashSet;  
    import java.util.Iterator;  
    import java.util.Random;  
    import java.util.Set;  
      
    public class RandomNumber {  
      
        /**
         * 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
         *  
         * @param begin
         *            最小数字（包含该数）
         * @param end
         *            最大数字（不包含该数）
         * @param size
         *            指定产生随机数的个数
         */  
        public static int[] generateBySet1(int begin, int end, int size) {  
            // 加入逻辑判断，确保begin<end并且size不能大于该表示范围  
            if (begin >= end || (end - begin) < size) {  
                return null;  
            }  
              
            Random ran = new Random();  
            Set<Integer> set = new HashSet<Integer>();  
            while (set.size() < size) {  
                set.add(begin + ran.nextInt(end - begin));  
            }  
              
            int[] ranArr = new int[size];  
            Iterator it = set.iterator();         
              
            for (int i = 0; i < size; i ++) {  
                if (!it.hasNext()) {  
                    break;  
                }  
                ranArr[i] = (Integer) it.next();              
            }  
            return ranArr;  
        }  
      
        /**
         * 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
         *  
         * @param begin
         *            最小数字（包含该数）
         * @param end
         *            最大数字（不包含该数）
         * @param size
         *            指定产生随机数的个数
         */  
        public static Integer[] generateBySet2(int begin, int end, int size) {  
            // 加入逻辑判断，确保begin<end并且size不能大于该表示范围  
            if (begin >= end || (end - begin) < size) {  
                return null;  
            }  
              
            Random ran = new Random();  
            Set<Integer> set = new HashSet<Integer>();  
            while (set.size() < size) {  
                set.add(begin + ran.nextInt(end - begin));  
            }  
              
            Integer[] ranArr = new Integer[size];  
            ranArr = set.toArray(new Integer[size]);  
            //ranArr = (Integer[]) set.toArray();  
              
            return ranArr;  
        }  
          
        public static void main(String[] args) {  
            Integer[] ranArr = generateBySet2(1, 35, 7);  
            for (int i : ranArr) {  
                System.out.print(i + "  ");  
            }  
      
        }  
    } 

三：即通过一个boolean数组来存储另一个数组的相同索引位置的字母是否已经使用

    import java.util.Arrays;  
      
    public class Game {  
      
        final static char[] letter = { '0', '1', '2', '3', '4', '5', '6', '7', '8',  
                '9' };  
          
        /**
         * 产生一个随机不重复的字符数组
         * @param n 指定产生序列的长度
         * @return
         */  
        public static char[] generateCharArr(int n) {  
            // 布尔型数组存储letter数组中相同下标的元素是否使用  
            boolean[] flag = new boolean[letter.length];  
            // 存放结果  
            char[] result = new char[n];  
            for (int i = 0; i < n; i++) {  
                int index;  
                do {  
                    index = (int) (Math.random() * (letter.length));  
                    result[i] = (char) (Math.random() * (letter.length));  
                } while (flag[index]);  
                result[i] = letter[index];  
                flag[index] = true;  
            }  
            return result;  
        }  
      
        public static void main(String[] args) {  
            System.out.println(Arrays.toString(generateCharArr(4)));  
        }  
    }