如何生成随机数、随机数去重

一时失言乱红尘 2022-12-28 08:09 229阅读 0赞

**随机数**

序言：复习排序算法时，想要通过生成随机数为数组赋值，java中产生随机数的方法主要有三种：

1.  `new Random()`，通过`java.util.Random`类实现
    
    ☆ `random()`：以当前时间(System.currentTimeMillis)为默认种子，每次生成的随机数是不同的
    
        public static void main(String[] args) { 
            Random random = new Random();
            for (int i = 0; i < 10; i++) { 
                int number = random.nextInt(100);
                System.out.print(number+" ");
                 /* * 10 83 92 56 88 85 64 75 55 29 * 90 3 71 52 69 80 13 84 23 18 * 61 85 94 40 47 40 28 66 69 73 */
           }
        }
    
    ☆`random(long seed)`：指定种子值，后面生成的随机数都与seed相关，简单来说就是将seed的值转换为随机数空间中的一个点，通过函数产生的随机数均匀散布在空间中
    
        public static void main(String[] args) { 
                Random random = new Random(1);
                for (int i = 0; i < 10; i++) { 
                    int a = random.nextInt(100);
                    System.out.print(a+" ");
                    
                    int b = random.nextInt(100);
                    System.out.println(b+" ");
                    /* * 85 88 * 47 13 * 54 4 * 34 6 * 78 48 * 69 73 * 17 63 * 62 34 * 92 62 * 96 89 */
                }
        }
    
    seed不变的情况下，每次执行生成的随机数是一样的，但是a和b不同，每调用一次nextInt就会重新计算一次
2.  `Math.random()`，通过`java.util.Math`类实现
    
    ☆ Math.random()是返回的\[0.0,1.0)之间的double型数值，包括0.0，不包括1.0。  
    ☆ Math.random()\*(100)则是取的\[0.0,100.0)范围，借助（int）来进行类型转换就可以得到整数随机数  
    ☆ 如果要求保证随机数的位数为三位，可以通过`(int) (random()*(900)+100)`  
    ☆ 生成指定区间 \[min,max)中随机值则为`(int) (random()*(max-min)+min)`  
    △ 例： \[20,60\]，(int) (random()\*40+20)
    
        /* * import static:静态导入包 * 作用：直接调用，简化操作 */
        import static java.lang.Math.random;
        import static java.lang.System.out;
        
        public class RandomDemo { 
            public static void main(String[] args) { 
                for (int i = 0; i < 10; i++) { 
                    int random = (int) (random()*100);
                    out.print(random + " ");
                    /* * 9 11 14 26 43 55 85 40 74 78 */
                }
            }
        }
    
    说到转型，顺带一提：
    
    ☆ 向上转型：char类型会直接转为Int而不是byte  
    ☆ 向下转型：double x 转为int需要通过(int) x进行强制类型转换，否则会报错  
    △ 定义变量`BigDecimal big;double d;`  
    △ BigDecimal转换为double需要通过`d = big.doubleValue()`转换  
    △ double转换为BigDecimal需要通过`big = BigDecimal.valueOf(d)`转换
    
        import static java.lang.System.out;
        
        public class PrimitiveOverloading { 
            void f1(char x){ out.print("f1(char) ");}
            void f1(byte x){ out.print("f1(byte) ");}
            void f1(int x){ out.print("f1(int) ");}
            void f1(short x){ out.print("f1(short) ");}
            void f1(long x){ out.print("f1(long) ");}
            void f1(float x){ out.print("f1(float) ");}
            void f1(double x){ out.print("f1(double) ");}
        
            void f2(byte x){ out.print("f2(byte) ");}
            void f2(int x){ out.print("f2(int) ");}
            void f2(short x){ out.print("f2(short) ");}
            void f2(long x){ out.print("f2(long) ");}
            void f2(float x){ out.print("f2(float) ");}
            void f2(double x){ out.print("f2(double) ");}
        
            void f3(int x){ out.print("f3(int) ");}
            void f3(short x){ out.print("f3(short) ");}
            void f3(long x){ out.print("f3(long) ");}
            void f3(float x){ out.print("f3(float) ");}
            void f3(double x){ out.print("f3(double) ");}
        
            void f4(short x){ out.print("f4(short) ");}
            void f4(long x){ out.print("f4(long) ");}
            void f4(float x){ out.print("f4(float) ");}
            void f4(double x){ out.print("f4(double) ");}
        
            void f5(long x){ out.print("f5(long) ");}
            void f5(float x){ out.print("f5(float) ");}
            void f5(double x){ out.print("f5(double) ");}
        
            void f6(float x){ out.print("f6(float) ");}
            void f6(double x){ out.print("f6(double) ");}
        
            void f7(double x){ out.print("f7(double) ");}
        
            void testChar(){ 
                char x = 'x';
                out.println("char: ");
                f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);
            }
        
            public static void main(String[] args) { 
                PrimitiveOverloading p = new PrimitiveOverloading();
                p.testChar();
                /* * 常数值5被当做int值处理，只要重载方法接收int就会被调用 * char: * f1(int) f2(int) f3(int) f4(long) f5(long) f6(float) f7(double) */
            }
        }
3.  通过`System.currentTimeMillis()`方法获取一个从1970年1月1日0时0分0秒到现在的毫秒数，取模之后得到所需范围内的随机数
    
        public static void main(String[] args) { 
                long random = System.currentTimeMillis();
                int num = (int) (random%100);
                out.println(num);
        }

\*\*扩展：\*\*这里我用到的是第二种取随机数的方式，但是这样生成的随机数会有重复的情况

array[i] = (int)(Math.random()*9999);

**那如何让生成的随机数不重复呢？**

1.  通过比较数组存在中的数据，如果数据中有相同的数据，退出内层循环并且i–,就再重新生成一个随机数据，直到在数组中没有相同数据，**但是如果循环次数过多会严重影响性能**

public static void main(String[] args) { 
        long start = System.currentTimeMillis();
        int[] arr=new int[50000];
        for(int i=0;i<arr.length;i++){ 
            // 调用Math.random(),生成范围在[1,50000]的数据
            arr[i]= (int) (Math.random()*(10000)+1);
            for(int j=0;j<i;j++){ 
                //比较随机数和数组存在中的数据
                if(arr[i]==arr[j]){ 
                    //有相同数据则退出内层循环，重新生成随机数
                    i--;
                    break;
                }
            }
        }
        System.out.println("耗时："+(System.currentTimeMillis()-start) + "ms");
        //输出结果：耗时：4762ms
        System.out.println("arr："+ Arrays.toString(arr));
        //arr：[16531, 31311, 49165, 2158 ...... 15578, 11751, 21269, 49528, 36063]
    }

1.  通过`ArrayList`的`remove`方法去重：先将0-49999添加到list中，然后生成随机数作为数组下标，通过remove()移除对应元素，最后得到的list长度缩减为原来的**一半**(50000—>25000)

public static void main(String[] args) { 
            long start = System.currentTimeMillis();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < 50000; i++) { 
                list.add(i);
            }
            
            for (int i = 0; i < list.size(); i++) { 
                int val = (int) (Math.random()*list.size());
                Object obj = list.get(val);
                list.remove(obj);
            }
            System.out.println("耗时："+(System.currentTimeMillis()-start) + "ms");
            //输出结果为：耗时：613ms
            System.out.println("List："+ list.toString());
        	//List：[1, 2, 5, 8, 9, 10, 11, 12, 13, 14, 18, 21, 22 ...... 49995, 49996, 49997]
        }

比较1，2方法：2的效率要高很多