java自动生成model Java自动生成流水号

JAVA根据0~9、A~Z生成流水码

最近项目中要生成7位流水码+前缀字母，以前系统用的自增长，最近自增长的长度已经不太够用了，再用段时间估计就得归0了，所以现在想着来修改一下生成规则，借鉴了一下CSDN上面大佬的代码，然后稍微修改了一下，更符合我的使用规则 ，原文参考：JAVA流水号生成规则，5位字符串，生成上千万uuid，使用0-9，A-Z36位来计算，按默认规则递增

直接上代码

@GetMapping("/insertNo")
    public  ApiResponseResult<String> insertNo(@Param("code") String code){
        //String code="0000A";
        //遍历1万条数据查看规则是否正确
        String listcode="";String currcode=code;
        for (int i = 0; i < 10000; i++) {
            currcode=sn(7, 9999999, currcode);
            if (currcode.contains("位数"))
                break;;
            listcode+=currcode+",\n";
        }
        return new ApiResponseResult<>(ApiResultCode.SUCCESS,listcode);
    }
    /**
     *
     * @param len 位数
     * @param i 若位数为5,则输入99999,若位数为3,则输入999,
     * @param driver 生成id的前一位 0000A
     * @return
     */
    public static String sn(int len,Integer i,String driver){
        //首先判断位数是否超出
        if (len>=driver.length()){
        String dr = "";
        AtomicInteger z = new AtomicInteger(i);
        z.getAndIncrement();
        if(z.toString().length()>(len-(driver!=null?driver.length():0))){
            dr = driverCheck(driver,len);
            if(dr.equals(".N")){//如超出限定长度并字母都为Z的时候，限定长度加1，dr重新开始，默认为空
                len++;
                dr = "";
            }else{
                z.set(1);
            }
        }else{
            dr = driver;
        }

        if(dr.length()==len){
            System.out.println(dr);
            return dr;
        }else{
            System.out.println(String.format("%0"+(len-(dr.length()))+"d",0)+dr);
            return String.format("%0"+(len-(dr.length()))+"d",0)+dr;
        }
        }else {
            return "位数超出";
        }
    }

    /**
     * 字母有效检查
     * 1.检查字母是否都为Z
     * 2.检查字母长度
     * @param driver
     * @param len
     * @return
     */
    public static String driverCheck(String driver,int len){
        char[] charArray = driver.toCharArray();
        AtomicInteger z = new AtomicInteger(0);

        for (char c : charArray) {
            if(c=='Z'){
                z.getAndIncrement();
            }
        }

        if(z.intValue()==driver.length() && z.intValue()==len){//如所有字母都为Z，并且长度达到限定长度，返回.N
            return ".N";
        }else if(z.intValue()==driver.length() && z.intValue()<len){//如果所有字母都为Z，但长度未达到限定长度，则在调用字母递增方法之前加入@用以递增A
            return driver("@"+driver);
        }else{//以上两个条件都不满足，则直接递增
            return driver(driver);
        }

    }

    /**
     * 字母递增
     * @param driver
     * @return
     */
    public static String driver(String driver){
        if(driver!=null && driver.length()>0){
            char[] charArray = driver.toCharArray();
            AtomicInteger z = new AtomicInteger(1);
            for(int i = charArray.length-1;i>-1;i--){
                if(charArray[i]=='Z'){
                    //最后一位A-Z
                    if (i==charArray.length-1) {//判断是否是最后一位
                        charArray[i]='0';
                        z.set(z.incrementAndGet());
                    } else if (z.intValue() > 0) {
                        //有前进位,其他位转为0
                        charArray[i] = '0';
                    }
                }else if(charArray[i]=='9'){
                    //如果有前进位,9进1,变A
                    if (z.intValue()>0) {
                        charArray[i] = 'A';
                        z.set(0);
                    }
                }
                else{
                    if(z.intValue()>0 || i==charArray.length-1){
                        AtomicInteger atomic = new AtomicInteger(charArray[i]);
                        charArray[i]=(char) atomic.incrementAndGet();
                        z.set(0);
                    }
                }
            }

            return String.valueOf(charArray);
        }else{
            return "A";
        }
    }