JAVA流水号生成规则，5位字符串，生成上千万uuid，使用0-9，A-Z36位来计算，按默认规则递增

因业务需要，原始uuid为5位，最多只支持10万条uuid，因业务量剧增，在不影响存量数据的情况下，需要拓展uuid，故将5位0-9的十进制规则，转换为0-9，A-Z36进制规则。
常规原则0000Z,后一位是000010，但000010存在于存量数据，故最后一位由A-Z组成.当0-99999用完后,转为0000A…0000Z…0001A…0001Z…0002A…0009Z…000AA…000ZZ…0010A…ZZZZZ.最后共计可以生成36^4*24=43670016个uuid.代码如下

package net.xdclass.controller;

import java.util.concurrent.atomic.AtomicInteger;

public class test {
    public static void main(String[] args) {
        String code="0000A";
        //遍历1万条数据查看规则是否正确
        for (int i = 0; i < 10000; i++) {
            code=sn(5, 99999, code);
        }
//        sn(5, 99999, "001ZZ");
    }

    /**
     *
     * @param len 位数
     * @param i 若位数为5,则输入99999,若位数为3,则输入999,
     * @param driver 生成id的前一位 0000A
     * @return
     */
    public static String sn(int len,Integer i,String driver){
        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);
        }else{
            System.out.println(String.format("%0"+(len-dr.length())+"d", z.intValue())+dr);
        }
        return dr;
    }

    /**
     * 字母有效检查
     * 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(0);
            for(int i = charArray.length-1;i>-1;i--){
                if(charArray[i]=='Z'){
                    //最后一位A-Z
                    if (i==charArray.length-1) {
                        charArray[i]='A';
                        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";
        }
    }

}