精华内容
下载资源
问答
  • 主要介绍了JAVA 16ID生成工具类含16位不重复的随机数数字+大小写,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 在开发过程中,会遇到生成XX编号之类的数据,而且这编号不能重复,所以根据当前时间,生成8位不重复的数.
  • 利用 Set 集合能存放重复元素的特性 package util; import java.util.HashSet; import java.util.Random; import java.util.Set; /** * @author ajun * Date 2021/7/14 * @version 1.0 * 工具类 */ public...

    实现原理

    利用 Set 集合不能存放重复元素的特性

    package util;
    
    import java.util.HashSet;
    import java.util.Random;
    import java.util.Set;
    
    /**
     * @author ajun
     * Date 2021/7/14
     * @version 1.0
     * 工具类
     */
    public class MyUitls {
        public static void main(String[] args) {
            Set<Integer> set = getRandoms(-30, -20, 5);
            System.out.println("数量:" + set.size());
            for (Integer s : set) {
                System.out.println(s);
            }
        }
    
        /**
         * 生成一组不重复随机数
         *
         * @param start 开始位置:可以为负数
         * @param end   结束位置:end > start
         * @param count 数量 >= 0
         * @return
         */
        public static Set<Integer> getRandoms(int start, int end, int count) {
            // 参数有效性检查
            if (start > end || count < 1) {
                count = 0;
            }
            // 结束值 与 开始值 的差小于 总数量
            if ((end - start) < count) {
                count = (end - start) > 0 ? (end - start) : 0;
            }
    
            // 定义存放集合
            Set<Integer> set = new HashSet<>(count);
            if (count > 0) {
                Random r = new Random();
                // 一直生成足够数量后再停止
                while (set.size() < count) {
                    set.add(start + r.nextInt(end - start));
                }
            }
            return set;
        }
    }
    

    数量:5
    -25
    -26
    -27
    -30
    -23

    展开全文
  • 使用了ArrayList和简单的循环来达到目的。用输入数字作为触发器。
  • Java生成指定位数不重复随机数。 2.风花雪月 2.1.随机数生成方法 Java 中常见的随机数的生成方式有三种: 第一种:通过 Math.random() 返回一个0(包含)到1(不包含)之间的 double 值。...

    楔子:或许我一次恋爱都不曾体验就老了。我可能无法和任何人恋爱。我可能一辈子都不会知道恋爱是什么。虽然我的大脑知道念念不忘某个人并为他哭泣、痛苦的感觉,比什么都不知道的要好,可是我的大脑并没有教我如何才能恋爱。- 宫部美雪《理由》

     

    1.今日书签

    Java生成随机数。
    Java生成指定位数不重复随机数。

     

    2.风花雪月

    2.1.随机数生成方法

    Java 中常见的随机数的生成方式有三种:

    第一种:通过 Math.random() 返回一个0(包含)到1(不包含)之间的 double 值。
    第二种:通过 Random 类来产生一个随机数。
    第三种:通过 System.currentTimeMillis() 来获取一个当前时间毫秒数的 long 型数字。

    代码示例参考在文末

     

    2.3.指定位数随机数

    通过以上三种方式,可演变的使用Java生成指定位数随机数的方式就有很多种,下面来扩列两种且小而巧的方法:

    2.3.1.使用 Math.random() 生成指定位数随机数

    比如生成指定8位随机数,可以像下面一样改造一下:

    int randomNum = (int) ((Math.random() * 9 + 1) * 10000000);

    注:参数 10000000 可以控制随机数位数,10000000 这样出来8位数,100000 这样出来6位数。

    注:(int) (Math.random() * 100 + 1) (int) (Math.random() * 101的区别:

    • Math.random() * 100 + 1:产生1~100之间的随机整数(包括1和100)
    • Math.random() * 101      :产生0~100之间的随机整数(包括0和100)

    测试结果:重复率比较高。

    随机生机8位数,100000次测试,生成不重复个数:99948,重复个数:52 

     

    2.3.2.使用 new Random() 生成指定位数随机数

    用 new Random().nextInt(); 可能会出现负数或较指定位数不够的情况。可以像下面一样改造一下补齐:

    String randomNum = String.format("%010d", Math.abs(new Random().nextInt()));

    随机示例:

        public static void main(String[] args) {
            String randomNum;
            List<String> numList1 = new ArrayList<>();
            List<String> numList2 = new ArrayList<>();
            for (int i = 0; i < 100000; i++) {
                randomNum = String.format("%010d", Math.abs(new Random().nextInt()));
                if (numList1.contains(randomNum)) {
                    numList2.add(randomNum);
                } else {
                    numList1.add(randomNum);
                }
            }
    
            System.out.println("随机生机10位数,100000次测试,生成不重复个数:" + numList1.size() + ",重复个数:" + numList2.size());
        }

    注:String 占位表达格式中:0代表前面要补的字符,10代表字符串长度,d表示参数为整数类型。

    测试结果:随机生成10万个随机数有点慢

    随机生机10位数,100000次测试,生成不重复个数:99998,重复个数:2

    100000个随机10位数,2个重复。但一般场景够用了。


    Java随机数测试示例:

    public class RandomTest {
    
        public static void main(String[] args) {
    
            // 通过Math.random()来获取随机数
            testMathRandom();
            System.out.println();
    
            // 通过默认构造方法构造Random类来获取随机数
            testNewRandom(new Random(), "通过默认构造方法构造Random类");
            // 通过指定种子数字构造Random类来获取随机数
            testNewRandom(new Random(1000), "通过指定种子数字构造Random类第一次");
            testNewRandom(new Random(1000), "通过指定种子数字构造Random类第二次");
            System.out.println();
    
            // 通过System.currentTimeMillis()来获取随机数
            testCurrentTimeMillis();
        }
    
        private static void testMathRandom() {
            // 通过Math的random()函数返回一个double类型随机数,范围[0.0, 1.0)
            double random1 = Math.random();
            System.out.println("通过 Math.random() 获取到随机数:" + random1);
    
            // 通过d获取一个[0, 100)之间的整数
            int random2 = (int) (random1 * 100);
            System.out.println("通过 Math.random() 获取到指定范围的随机数:" + random2);
        }
    
        private static void testNewRandom(Random random, String marker) {
            // 获取随机的boolean值
            boolean nextBoolean = random.nextBoolean();
            // 获取随机的Double值,范围[0.0, 1.0)
            double nextDouble = random.nextDouble();
            // 获取随机的float值,范围[0.0, 1.0)
            float nextFloat = random.nextFloat();
            // 获取随机的int值
            int nextInt = random.nextInt();
            // 获取随机的[0,100)之间的int值
            int nextIntBound = random.nextInt(100);
            // 获取随机的高斯分布的double值
            double nextGaussian = random.nextGaussian();
            // 获取随机的long值
            long nextLong = random.nextLong();
    
            // 通过Math的random()函数返回一个double类型随机数,范围[0.0, 1.0)
            double random1 = Math.random();
            System.out.printf("%s获取到的随机数:\r\n" +
                            "boolean值:%s,Double值:%s,Float值:%s,int值:%s," +
                            "int Bound值:%s,Gaussian double值:%s,long值:%s",
                    marker, nextBoolean, nextDouble, nextFloat,
                    nextInt, nextIntBound, nextGaussian, nextLong);
    
            System.out.println();
        }
    
        private static void testCurrentTimeMillis() {
            // 通过System.currentTimeMillis()来获取一个当前时间毫秒数的long型数字
            Long randomNum1 = System.currentTimeMillis();
            System.out.println("通过 System.currentTimeMilliss() 获取到随机长整数:" + randomNum1);
    
            // 获取一个[0, 100)之间的整数
            // 获取一个当前时间毫秒数的long型数字,取模之后即可得到所需范围内的随机数
            int randomNum2 = (int) (randomNum1 % 100);
            System.out.println("通过 System.currentTimeMilliss() 获取到指定范围的随机数:" + randomNum2);
        }
    }

    测试结果:

    通过 Math.random() 获取到随机数:0.36249263252080566
    通过 Math.random() 获取到指定范围的随机数:36
    
    通过默认构造方法构造Random类获取到的随机数:
    boolean值:true,Double值:0.15312096796280816,Float值:0.068893015,int值:1956732642,int Bound值:16,Gaussian double值:0.4268972545430564,long值:-2862893424168180428
    通过指定种子数字构造Random类第一次获取到的随机数:
    boolean值:true,Double值:0.24691546819860266,Float值:0.46028805,int值:-230127712,int Bound值:49,Gaussian double值:-0.5712614462078893,long值:8222391730744523982
    通过指定种子数字构造Random类第二次获取到的随机数:
    boolean值:true,Double值:0.24691546819860266,Float值:0.46028805,int值:-230127712,int Bound值:49,Gaussian double值:-0.5712614462078893,long值:8222391730744523982
    
    通过 System.currentTimeMilliss() 获取到随机长整数:1587091175269
    通过 System.currentTimeMilliss() 获取到指定范围的随机数:69

     

    展开全文
  • 在项目中遇到客户一个需求,ID的生成策略:长度8,用户在知道自己的ID(如:10000018)后,能通过ID来推测相关信息,如用户可能推测我是第18个注册用户,上一个注册用户的ID是10000017,这样就能很好的保护...

    在项目中遇到客户一个需求,ID的生成策略:长度8位,用户在知道自己的ID(如:10000018)后,不能通过ID来推测相关信息,如用户可能推测我是第18个注册用户,上一个注册用户的ID是10000017,这样就不能很好的保护账号安全了,可以凭证推测数据来进行不法之事。

    经过网上查找和思考,便有了如下的解决方案:

    • 生成一个装有1-99999999数值的数组
    • 将数值内的值随机打乱
    • 将数值的值分开保存到不同的文件(txt)中
    • 获取ID的时候,可以随机从任意一文件中获取第一行的ID值,然后将剩余行的ID值重写写会原文件
    • 如果文件中的ID值已经取完则删除

    逻辑很简单,就看实现了,代码如下:

    生成ID并保存到硬盘

        /**
         * 生成1-99999999的数字编码保存到硬盘
         */
        private static void generateAppCode2Disk(){
            int begin = 1;  
            int end = 99999999;  
            int count = begin + end;  
            //生成1到99999999的所有整数  
            int[] codes = new int[count + 1];  
            for (int i = begin; i <= end; i++){  
                codes[i] = i;  
            }
            //随机交换数据  
            int index = 0;
            int tempCode = 0;
            Random random = new Random();
            for (int i = begin; i <= end; i++){  
                index = random.nextInt(count+1);  
                tempCode = codes[index];  
                codes[index] = codes[i];  
                codes[i] = tempCode;  
            }
            //生成1000个文件,每个文件包含100000个appCode
            StringBuilder sb = new StringBuilder();
            int flag = 100000;
            System.out.println("***********开始**********");
            try {
                for(int i = begin; i <= end; i++){
                    sb.append(codes[i]).append("\n");
                    if(i == end || i%flag == 0){
                        File folder = new File("D:/IDGenerate");
                        if(!folder.isDirectory()){
                            folder.mkdir();
                        }
                        if(i==end){
                            i = end +1;
                        }
                        File file = new File("D:/IDGenerate/ID_"+(i/flag)+".txt");
                        if (!file.exists()) {
                            file.createNewFile();
                        }
                        BufferedWriter bw=new BufferedWriter(new FileWriter(file.getAbsoluteFile()));
                        bw.write(sb.toString());
                        bw.flush();
                        bw.close();
                        sb = new StringBuilder();
                        System.out.println("当前i值:"+i+"第"+(i/flag)+"个文件生成成功!");
                    }
                }
                System.out.println("***********结束**********");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    获取ID

        //获取唯一8位ID
        public String createAppCode(){
            BufferedWriter bw = null;
            BufferedReader br = null;
            FileReader fr = null;
            FileWriter fw = null;
            try {
                String dir = "D:/";
                if(StringUtils.isBlank(dir)){
                    throw new Exception("获取文件路径为空");
                }
                File rootFile = new File(dir);
                String[] fileNames = rootFile.list();
                if(fileNames == null || fileNames.length == 0){
                    throw new Exception("路径不正确,或者ID已经分配完毕,请联系管理员");
                }
                //获取第一个文件
                fr=new FileReader(dir+"/"+fileNames[0]);//获取文件流
                br = new BufferedReader(fr); //将流整体读取。
                StringBuilder sb = new StringBuilder();
                String appCode = "";
                String temp;
                int count =1;
                while(!StringUtils.isBlank(temp=br.readLine())){
                    if(count == 1){
                        count++;
                        appCode = temp;
                        continue;
                    }
                    else{
                        sb.append(temp).append("\n");
                    }
    
                }
                br.close();
                fr.close();
                if(!StringUtils.isBlank(appCode)){
                    //判断文件内容是否还有下一行
                    if(sb.length()<=0){
                        File delFile = new File(dir+"/"+fileNames[0]);
                        if(delFile.exists()){
                            delFile.delete();//删掉
                        }
                    }
                    else{
                        //将剩余内容重写写回文件
                        fw = new FileWriter(dir+"/"+fileNames[0]);
                        bw=new BufferedWriter(fw);
                        bw.write(sb.toString());
                        bw.flush();
                        bw.close();
                        fw.close();
                    }
                    String prex = "00000000";
                    appCode = prex.substring(0,prex.length()-appCode.length())+appCode;
                    return appCode;
                }
                else{
                    throw new Exception("文件中内容为空");
                }
            } catch (Exception e) {
                log.error("获取ID error:"+e.getMessage());
                return null;
            } finally{
                try {
                    if(bw != null)bw.close();
                    if(br != null)bw.close();
                    if(fr != null)bw.close();
                    if(fw != null)bw.close();
                } catch (IOException e) {
                    log.error("关闭文件流文件异常:"+e.getMessage());
                }
            }
        }

    这样将生成的ID分成1000个文件保存到硬盘,取数据的时候从任意文件中取都可,这样能很好的保证了随机,不重复,而且在测试的时候发现效率还不错,内存,CPU的使用都微乎其微。

    为了更好的优化获取ID效率,可以有如下改进:

    • 将ID保存到更多的文件中,这样文件的容量就可以很小,加载的时候就更快
    • 预读ID,可以提前预读50,100等数量的ID保存到list中,直接从内存取数据就更快了,不过这逻辑就复杂了很多,要保证list的数据和硬盘数据的同步,就需要更多的代码来判断了

      此文章供大家参考,大家有什么好的建议,算法都可以提出来交流的!

    展开全文
  • Java生成不重复的任意随机数

    热门讨论 2008-11-06 11:42:55
    巧用Java实现得到任意永不重复的随机数,很经典的代码!
  • Java生成不重复的随机数

    千次阅读 2020-07-06 20:51:42
    import java.util.Arrays; public class NoRepeatRandomNumber { public static void main(String[] args) { getNotNumber1(); getNotNumber2(); } public static void getNotNumber1(){ //1. 声明整型数组
    package self.exercise;
    
    import java.util.Arrays;
    
    public class NoRepeatRandomNumber {
        public static void main(String[] args) {
            getNotNumber1();
            getNotNumber2();
        }
    	
    	//方法一
        public static void getNotNumber1(){
            //1. 声明整型数组
            int[] numbers=new int[10];
            //2. 思路: 通过一个while循环来不断生成随机数,通过for循环来剔除重复的随机数
            int index = 0;//初始化需要的随机数 个数
            while (true) {
                int random = (int)(Math.random() * 32 + 1); //生成随机数1~32
                int j = 0;//后面需要对 j 进行判断,需要提升变量作用域
                for ( ; j < numbers.length ; j++) { // 遍历numbers数组,如果出现重复就跳出for循环
                    if(random == numbers[j]) break;
                }
                if(j == numbers.length ) numbers[index++] = random; // 说明没有重复,就可以存放随机数字到指定的位置了
                if (index == 10) break;//达到numbers数组的容量就结束
            }
            System.out.println(Arrays.toString(numbers));
        }
    	
    	//方法二
        public static void getNotNumber2(){
            //1. 声明整型数组
            int[] numbers=new int[10];
            //2. 思路: 通过一个外层for循环来不断生成随机数,通过内层for循环来剔除重复的随机数
            for (int i = 0; i < 10; ) {
                int random = (int)(Math.random() * 32 + 1);//1~32
                int j = 0;//后面需要对 j 进行判断,需要提升变量作用域
                for (; j < numbers.length; j++) {
                    if (random == numbers[j]) break;//遍历numbers数组,如果出现重复就跳出for循环
                }
                if(j == numbers.length ) numbers[i++] = random; //能到达这一步,说明没有重复,就可以存放随机数字到指定的位置了
            }
            System.out.println(Arrays.toString(numbers));
        }
    }
    
    
    展开全文
  • Java生成不重复随机数

    千次阅读 2019-08-15 21:58:29
    关于生成不重复随机数算法的应用场景:** 1、考试系统中生成不重复试题的算法及程序设计; 2、一种随机的音乐播放列表; 3、随机抽样模型; 4、工作人员随机分配工作地点; 5、接单系统随机分配满足条件的多条匹配...
  • java生成10位不重复的字母+数字组合

    千次阅读 2014-07-07 16:46:48
    最近项目需求,需要生成10位不重复的字母+数字组合。开始时将数据向数据库中插入。再插入的时候需要跟数据库一个个的比对。非常慢。就想,如果前四前缀固定的话,每次插入前,查询数据库是否存在这个前缀,不存在...
  • 这还简单吗,用Java的Math.random就可以生成随机数了,网上一大堆的博文,还有些是uuid生成字母家数字的,而且这种方法生成时间需要10秒以上,还有一点生成一千万的时候有重复出现的,这种方法绝壁不行,上代码: ...
  • 直接运行main即可,参数为数字范围 比如10 运行后会输出9,3,0,7,2,8,4,1,5,6,
  • JAVA随机生成10不重复数字:简单做法 public class text1{ public static void main(String[] args) { int arr[]=new int[10]; //定义一个长度为10的一维数组存放随机数 for (int j = 0; j < arr.length; j+...
  • 生成多个不重复的随机数的需求场景: 1.抽奖系统 2.一些加密算法,比如在密码学中生成Nonce 3.随机播放 4.游戏中的随机数,比如卡牌类游戏中刷新卡牌,抽取卡牌 因为班级人数还有座位数都是确定的,所以也没有写的太...
  • java 生成20个不重复的随机数

    千次阅读 2020-07-30 10:34:31
    import java.util.Random; import java.util.Vector; public class test { public static void main(String []args) { //创建一个产生随机数的对象 Random r = new Random(); //创建一个存储随机数的集合 ...
  • * 利用set的无序性产生不重复的随机整数数组 * @param min 整数数组的最小值 * @param max 整数数组的最大值 * @return */ public static int[] randSort(int min,int max) { int
  • import java.util.Random; public class NumberGenerator { public NumberGenerator() { } public static long getNumber(int length) { StringBuilder buf = new StringBuilder(); Random random = new ...
  • java 生成不重复随机数 数字类型方法 import java.math.BigInteger; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; import java.util.UUID; ...
  • import java.util.Arrays; import java.util.... //随机生成20个三位整数不重复,并且从小到大排列 public static void main(String[] args) { HashSet<Integer> set=new HashSet<Integer>...
  • Java随机生成0-9不重复数字

    千次阅读 2020-07-15 14:55:08
    Java随机生成0-9不重复数字 public static Random myRandom = new Random(System.currentTimeMillis()); public static String getRandom() { String Num = ""; List<String> list = new ArrayList<...
  • import java.util.Comparator; import java.util.Random; import java.util.TreeSet; public class Paixu { public static void main(String[] args) { Random r=new Random(); class Rule imp...
  • * 随机生成不重复的随机数 * @param min 最小值 * @param max 最大值 * @param size 个数 * @return */ public static List<Integer> getRandom(int min,int max,int size){ List<Integer>
  • Java生成随机不重复的数字

    万次阅读 2018-02-03 14:18:53
    import java.util.ArrayList;... * 0-28个数之间随机9个数,重复 *分析: 先循环输出28个数 * 在随机九个元素 * 将随机出来的第一个数移除 * 再重新循环一次 */ public class Randoma { public static void
  • 我看了我6L的,说实话,他的程序还不错,只是他忽略了一点,他的循环只有一次,而如果数字有重复的情况下,SET就很难存到 10 个数字,信的话,楼主可以吧他程序里的 100 改成 20 试试,问题就很明显了。...
  • String bookNo="1"; Date date=new Date(); SimpleDateFormat sdf1=new SimpleDateFormat("yyyyMMdd"); String times=sdf1.format(date); NumberFormat f= new Decim...
  • 生产不重复19随机数,测试1000000数据没重复
  • java中的Math类中存在一个random()方法,该方法默认生成0.0到1.0之间的double型随机数;经过稍微处理,就可以产生我们需要的随机数以及随机字符。 除了Math类中的random()方法之外,java.util.Random类也可以用来...
  • 该代码采用面向对象语言实现不重复的随机数,用四种方法。谢谢参考
  • 随机生成10不重复的数字存入集合中,并遍历集合 import java.util.LinkedHashSet; import java.util.Random; import java.util.Set; public class Test { public static void main(String[] args) { //随机生成...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,377
精华内容 27,750
关键字:

java生成10位的不重复整数

java 订阅