利用网上的Caesar算法写了一个全局唯一id生成类

工作中需要用到，不需要用uuid这种太长的，但是需要有自己特色标识的，于是晚上搜集了部分算法和思路，加工出来一个唯一随机id生成类

思路：改造过的Caesar算法，利用随机数加密，生成前12位 + 后4位随机数，经测试大量数据和实际使用验证，无重复值出现，可以放心使用

	// key
	private static String KEYS = "0123456789qwertyuiopasdfghjklzxcvbnm";

	/**
	 * 唯一id生成工具类，12位字母+数字
	 * 
	 * @param id 随机整数即可
	 */
	public static String getRandomId(int id)
	{
		String ret = null;
		String num = String.format("%09d", id);
		Random random = new Random();
		int key = random.nextInt(10);
		int seed = random.nextInt(100);
		Caesar caesar = new Caesar(KEYS, seed);
		num = caesar.encode(key, num);
		ret = num + String.format("%01d", key) + String.format("%02x", seed);

		return ret;
	}
	
	/**
	 * id唯一值生成工具类<br>
	 * 格式：test_xxxx，总共21位随机码 
	 * @return test_+16位随机码
	 */
	public static String getID()
	{
		// 前缀
		String prefix = "test_";
		// 随机码
		String main = TestRandomUUID.getRandomId(new Random().nextInt(1000000));
		String end = RandomUtils.getRandomAlphamericStrNew(4);
		
		return prefix + main + end;
	}

public class RandomUtils
{
	 /**
     * 获得特定长度的一串随机数字
     * 
     * @param length 
     * @return
     */
    public static String getRandomNumberStr(int length)
    {
        StringBuilder builder = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < length; i++)
        {
            builder.append(random.nextInt(10));
        }
        return builder.toString();
    }

    /**
     * 获得特定长度的一个随机字母数字混编字符串（所包含的字符包括0-9A-Z)
     * 
     * @param length
     * @return
     */
    public static String getRandomAlphamericStr(int length)
    {
        StringBuilder builder = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < length; i++)
        {
            int n = random.nextInt(36);
            if (n < 10)
            {
                builder.append(n);
            }
            else
            {
                builder.append((char) (n + 55));
            }
        }
        return builder.toString();
    }

    /**
     * 获得特定长度的一个随机字母数字混编字符串（所包含的字符包括0-9a-z)
     * 
     * @param length
     * @return
     */
    public static String getRandomAlphamericStrNew(int length)
    {
        StringBuilder builder = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < length; i++)
        {
            int n = random.nextInt(36);
            if (n < 10)
            {
                builder.append(n);
            }
            else
            {
                builder.append((char) (n + 87));
            }
        }
        return builder.toString();
    }

    /**
     * 获得特定长度的一个随机十六进制数字字母混编字符串(所包含的字符包括0-9A-F)
     * 
     * @param length
     * @return
     */
    public static String getRandomHexStr(int length)
    {
        StringBuilder builder = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < length; i++)
        {
            int n = random.nextInt(16);
            if (n < 10)
            {
                builder.append(n);
            }
            else
            {
                builder.append((char) (n + 55));
            }
        }
        return builder.toString();
    }

    public static void main(String[] args)
    {
        for (int i = 0; i < 100; i++)
        {
            System.out.println(RandomUtils.getRandomAlphamericStrNew(4));
            // String num = String.format("%09d", new Random().nextInt(100000));
            // System.out.println(num);
        }

    }
}

public class Caesar
{
	private String table;
	private int seedA = 1103515245;
	private int seedB = 12345;

	public Caesar(String table, int seed)
	{
		this.table = chaos(table, seed, table.length());
	}

	public Caesar(String table)
	{
		this(table, 11);
	}

	public Caesar()
	{
		this(11);
	}

	public Caesar(int seed)
	{
		this("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", seed);
	}

	public char dict(int i, boolean reverse)
	{
		int s = table.length(), index = reverse ? s - i : i;
		return table.charAt(index);
	}

	public int dict(char c, boolean reverse)
	{
		int s = table.length(), index = table.indexOf(c);
		return reverse ? s - index : index;
	}

	public int seed(int seed)
	{
		long temp = seed;
		return (int) ((temp * seedA + seedB) & 0x7fffffffL);
	}

	public String chaos(String data, int seed, int cnt)
	{
		StringBuffer buf = new StringBuffer(data);
		char tmp;
		int a, b, r = data.length();
		for (int i = 0; i < cnt; i += 1)
		{
			seed = seed(seed);
			a = seed % r;
			seed = seed(seed);
			b = seed % r;
			tmp = buf.charAt(a);
			buf.setCharAt(a, buf.charAt(b));
			buf.setCharAt(b, tmp);
		}
		return buf.toString();
	}

	public String crypto(boolean reverse, int key, String text)
	{
		String ret = null;
		StringBuilder buf = new StringBuilder();
		int m, s = table.length(), e = text.length();

		for (int i = 0; i < e; i += 1)
		{
			m = dict(text.charAt(i), reverse);
			if (m < 0)
			{
				break;
			}
			m = m + key + i;
			buf.append(dict(m % s, reverse));
		}
		if (buf.length() == e)
		{
			ret = buf.toString();
		}
		return ret;
	}

	public String encode(int key, String text)
	{
		return crypto(false, key, text);

	}

	public String decode(int key, String text)
	{
		return crypto(true, key, text);
	}

	public static void main(String[] args)
	{
		Caesar caesar = new Caesar("0123456789qwertyuiopasdfghjklzxcvbnm");
		String data = caesar.encode(32, "23423");
		System.out.println(data);
		String pass = caesar.decode(32, data);
		System.out.println(pass);

	}
}