[更改流水号规则]JAVA流水号生成规则(按默认规则递增，数字不够添加字母递增，位数不够自动加1)

流水号生成规则 写道

1.设置默认流水号限定长度规则
2.流水号达到最大限度时，长度+1，流水号从1开始重新来过
3.流水号数字递增部分达到99...9的时候，如果没有超出流水号长度的最大范围，则增加字母加入流水号，直至字母都为ZZ..Z的时候，长度+1，流水号从1开始重新来过
4.流水号可以限定字母流水的长度

预计期望：
流水号规则：
流水号最大长度：5
字母限定长度：2

00001~99999
A0001~A9999
....
Z0001~Z9999
ZA001~ZA999
...
ZZ001~ZZ999
000001~999999

 /**
 *
 */
package com.mw.framework.util;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Project MeWeb
 * @Copyright © 2008-2014 SPRO Technology Consulting Limited. All rights reserved.
 * @fileName com.mw.framework.util.SerialNumberUtils.java
 * @Version 1.0.0
 * @author Allan Ai
 * @time 2014-7-22
 *
 */
public class SerialNumberUtils {
	
	public static String[] sn(int len,Integer i,String driver,String prefix,int limited){
		String[] result = new String[4];
		AtomicInteger z = new AtomicInteger(i);
		AtomicInteger x = new AtomicInteger(i);
		driver = driver==null?"":driver;
		prefix = prefix==null||prefix.equals("null")?"":prefix;
		//1.判断流水号长度是否大于约定长度
		if(z.toString().length()<=(len-driver.length())){
			if(Integer.valueOf(x.incrementAndGet()).toString().length()>(len-driver.length())||(driver.length()>limited && limited!=-1)){
				System.out.println("默认索引超出范围,需从字母A开始重新一轮的流水号");
				//2.如果流水号+字母长度超过了最大限度修改新的长度
				//len=String.valueOf(x.get()).length();
				int temp  = String.valueOf(x.get()).length();
				
				AtomicInteger atomicInteger = new AtomicInteger(0);
				char[] charArray = driver.toCharArray();
				
				for (char c : charArray) {
					if(c=='Z'){
						atomicInteger.getAndIncrement();
					}
				}
				
				if((temp+driver.length()>len && atomicInteger.intValue()==driver.length() && driver.length()>0) ||(driver.length()>limited && limited!=-1)){
					System.out.println("如果流水号+字母长度超过了最大限度修改新的长度,并重新开始一轮+1的流水号");
					len++;
					driver="";
				}else{
					driver = driverCheck(driver,len,limited);
					if(driver.equals(".N")){
						driver = "";
					}
				}
				z.set(0);
			}
			
			
			
			String current = String.format("%0"+(len-driver.length())+"d",z.incrementAndGet());
			result[0]=prefix+driver+current;
			result[1]=driver;
			result[2]=String.valueOf(len);
			result[3]=String.valueOf(z.get());
			System.out.println(prefix+driver+current);
		}else{
			System.out.println("输入不合法！");
		}
		
		return result;
	}
	
	/**
	 * 字母有效检查
	 * 1.检查字母是否都为Z
	 * 2.检查字母长度
	 * @param driver
	 * @param len
	 * @return
	 */
	public static String driverCheck(String driver,int len,int limited){
		if(driver!=null && driver.length()>0){
			AtomicInteger z = new AtomicInteger(0);
			char[] charArray = driver.toCharArray();
			
			for (char c : charArray) {
				if(c=='Z'){
					z.getAndIncrement();
				}
			}
			
			if(z.intValue()==driver.length()){
				String result = "";
				if(z.intValue()==len && z.intValue()>limited){//如所有字母都为Z，并且长度达到限定长度，返回.N
					System.out.println("如所有字母都为Z，并且长度达到限定长度，返回.N");
					result = ".N";
				}else if(z.intValue()<len-1 && z.intValue()<=limited){
					System.out.println("如果所有字母都为Z，但长度未达到限定长度,直接递增");
					result = driver(driver+"@");
				}
				return result;
			}else{
				System.out.println("以上两个条件都不满足，则直接递增");
				return driver(driver);
			}
			/*if(z.intValue()==driver.length() && z.intValue()==len){//如所有字母都为Z，并且长度达到限定长度，返回.N
				return ".N";
			}else if(z.intValue()==driver.length() && z.intValue()<len){//如果所有字母都为Z，但长度未达到限定长度，则在调用字母递增方法之前加入@用以递增A
				System.out.println(z.intValue());
				System.out.println(driver.length());
				return driver2(driver);
				
			}else{//以上两个条件都不满足，则直接递增
				return driver2(driver);
			}*/
		}else{
			return "A";
		}
	}
	
	/**
	 * 字母递增
	 * @param driver
	 * @return
	 */
	public static String driver(String driver){
		
		if(driver!=null && driver.length()>0){
			char[] charArray = driver.toCharArray();
			boolean bool = false;
			for(int i = charArray.length-1;i>-1;i--){
				if(charArray[i]=='Z'){
					if(i==charArray.length-1){
						charArray[i]='A';
						bool = true;
					}else{
						if(bool==true){
							AtomicInteger atomic = new AtomicInteger(charArray[i]);
							int val = atomic.incrementAndGet();
							if(90>=val){
								charArray[i]=(char) val;
								bool = false;
							}else{
								charArray[i]='A';
								bool = true;
							}
						}
					}
				}else{
					if(bool==true || (i==charArray.length-1)){
						AtomicInteger atomic = new AtomicInteger(charArray[i]);
						int val = atomic.incrementAndGet();
						if(90>=val){
							charArray[i]=(char) val;
							bool = false;
						}else{
							charArray[i]='A';
							bool = true;
						}
					}
				}
				
			}
			return String.valueOf(charArray);
		}else{
			return "A";
		}
	}
	
 
	public static void main(String[] args) {
		String[] s_= sn(5,9, "ZYAS","",-1);
		for (String string : s_) {
			System.out.println(string);
		}
		
	}
}