java 生成22位UUID 改造

背景：数据库的前期设计，主键用的是uuid，但这个是大数据量的应用。经过n久的折腾，数据大于1亿条了。返回去看表，发现，表的很多字段是varchar2的，但是长度不超过20字符。占据大部分空间的居然是uuid。于是萌生改造uuid的想法。

 

过程：经过一番搜索，一般就是缩短至22位的uuid了。

这位仁兄是由短域名想到uuid用64进制改造http://www.iteye.com/topic/1028058，其方法是把uuid生成的字符串去掉“-”，在补一个“0”，得到33位的16进制数，再用22个64进制数表示。

 

而这位仁兄呢，想到的是用base64的方法缩短uuid，http://cengjingdemimang.iteye.com/blog/1022149。看了代码，主要是利用uuid生成的mostSigBits、leastSigBits来做位移，再通过base64的算法将16字节的2个long类型转换成字符。经过本人一番搜索，在网上找到这位作者可能直接使用的base64的代码http://blog.csdn.net/lastsweetop/article/details/5314640（^_^就是不用做什么封装直接用的代码）。

 

接着呢，就是把这两位仁兄的22位uuid生成速度做一番比较。显然，第二位的速度快一些，因为少了字符串操作。于是采用第二位仁兄的方法。但是呢，看着看着我就糊涂了。因为这里有段奇怪的代码。

[java] view plain copy

1. for (int i = 8; i < 16; i++) {  
2.         buffer[i] = (byte) (lsb >>> 8 * (7 - i));  
3. }  

右移负数。经过我一番尝试，得出一个比较随意的结论：右移负数可以得到数字。

[java] view plain copy

1. int a = 3*2^28;  
2. System.out.println(a>>>28);//输出3  
3. System.out.println(a>>>-4);//输出3  
4. //28-(-4)=32  
5. int b = 3*2^4;  
6. System.out.println(b>>>4);//输出3  
7. System.out.println(b>>>-28);//输出3  
8. //这个是变相的左移？  

之后，我研究了第二位仁兄的方法，结合base64，大概是这样的，把mostSigBits、leastSigBits转成16字节的字节数组，然后采用3个字节分为4个字节，再对应64进制的字符。采用自己的写法，得到以下代码。

[java] view plain copy

1. //import java.util.Date;  
2. import java.util.UUID;  
3.   
4. public class UUID22 {  
5.   
6.     /** 
7.      * 采用URL Base64字符，即把“+/”换成“-_” 
8.      */  
9.     static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=".toCharArray();  
10.       
11.     /** 
12.      * Base64 编码 
13.      * @param data 
14.      * @return 
15.      */  
16.     private char[] encode(byte[] data) {  
17.         char[] out = new char[((data.length + 2) / 3) * 4];  
18.         boolean quad, trip;  
19.         for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {  
20.             quad = trip = false;  
21.             int val = (0xFF & (int) data[i]);  
22.             val <<= 8;  
23.             if ((i + 1) < data.length) {  
24.                 val |= (0xFF & (int) data[i + 1]);  
25.                 trip = true;  
26.             }  
27.             val <<= 8;  
28.             if ((i + 2) < data.length) {  
29.                 val |= (0xFF & (int) data[i + 2]);  
30.                 quad = true;  
31.             }  
32.             out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];  
33.             val >>= 6;  
34.             out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];  
35.             val >>= 6;  
36.             out[index + 1] = alphabet[val & 0x3F];  
37.             val >>= 6;  
38.             out[index + 0] = alphabet[val & 0x3F];  
39.         }  
40.         return out;  
41.     }  
42.       
43.     /** 
44.      * 转成字节 
45.      * @return 
46.      */  
47. //  private byte[] toBytes(String u) {  
48. //      UUID uuid = UUID.fromString(u);  
49.     private byte[] toBytes() {  
50.         UUID uuid = UUID.randomUUID();  
51.         long msb = uuid.getMostSignificantBits();  
52.         long lsb = uuid.getLeastSignificantBits();  
53.         byte[] buffer = new byte[16];  
54.   
55.         for (int i = 0; i < 8; i++) {  
56.             buffer[i] = (byte) ((msb >>> 8 * (7 - i)) & 0xFF);  
57.             buffer[i + 8] = (byte) ((lsb >>> 8 * (7 - i)) & 0xFF);  
58.         }  
59.         return buffer;  
60.     }  
61.       
62. //  public String getUUID(String u) {  
63. //      char[] res = encode(toBytes(u));  
64.     public String getUUID() {  
65.         char[] res = encode(toBytes());  
66.         System.out.println(new String(res));  
67.         return new String(res, 0, res.length - 2);  
68.     }  
69.       
70.     public static void main(String[] args) {  
71.         System.out.println(getUUID22());  
72. //      System.out.println(getUUID("c19b9de1-f33a-494b-afbe-f06817218d64"));  
73. //      System.out.println(getUUID22("c19b9de1-f33a-494b-afbe-f06817218d64"));  
74. //      Date d1 = new Date();  
75. //      for(int i = 0; i < 1000000; i++) {  
76. //          UUID.randomUUID().toString();  
77. //          getUUID22();  
78. //      }  
79. //      Date d2 = new Date();  
80. //      System.out.print(d2.getTime() - d1.getTime());  
81.     }  
82.       
83.     /** 
84.      * 将随机UUID转换成22位字符串 
85.      * @return 
86.      */  
87. //  public static String getUUID22(String u) {  
88. //      UUID uuid = UUID.fromString(u);  
89.     public static String getUUID22() {  
90.         UUID uuid = UUID.randomUUID();  
91. //      System.out.println(uuid.toString());  
92.         long msb = uuid.getMostSignificantBits();  
93.         long lsb = uuid.getLeastSignificantBits();  
94.         char[] out = new char[24];  
95.         int tmp = 0, idx = 0;  
96.         // 基础写法  
97.         /*tmp = (int) ((msb >>> 40) & 0xffffff); 
98.         out[idx + 3] = alphabet[tmp & 0x3f]; 
99.         tmp >>= 6; 
100.         out[idx + 2] = alphabet[tmp & 0x3f]; 
101.         tmp >>= 6; 
102.         out[idx + 1] = alphabet[tmp & 0x3f]; 
103.         tmp >>= 6; 
104.         out[idx] = alphabet[tmp & 0x3f]; 
105.         idx += 4; 
106.          
107.         tmp = (int) ((msb >>> 16) & 0xffffff); 
108.         out[idx + 3] = alphabet[tmp & 0x3f]; 
109.         tmp >>= 6; 
110.         out[idx + 2] = alphabet[tmp & 0x3f]; 
111.         tmp >>= 6; 
112.         out[idx + 1] = alphabet[tmp & 0x3f]; 
113.         tmp >>= 6; 
114.         out[idx] = alphabet[tmp & 0x3f]; 
115.         idx += 4; 
116.          
117.         tmp = (int) (((msb & 0xffff) << 8) | (lsb >>> 56 & 0xff)); 
118.         out[idx + 3] = alphabet[tmp & 0x3f]; 
119.         tmp >>= 6; 
120.         out[idx + 2] = alphabet[tmp & 0x3f]; 
121.         tmp >>= 6; 
122.         out[idx + 1] = alphabet[tmp & 0x3f]; 
123.         tmp >>= 6; 
124.         out[idx] = alphabet[tmp & 0x3f]; 
125.         idx += 4; 
126.          
127.         tmp = (int) ((lsb >>> 32) & 0xffffff); 
128.         out[idx + 3] = alphabet[tmp & 0x3f]; 
129.         tmp >>= 6; 
130.         out[idx + 2] = alphabet[tmp & 0x3f]; 
131.         tmp >>= 6; 
132.         out[idx + 1] = alphabet[tmp & 0x3f]; 
133.         tmp >>= 6; 
134.         out[idx] = alphabet[tmp & 0x3f]; 
135.         idx += 4; 
136.          
137.         tmp = (int) ((lsb >>> 8) & 0xffffff); 
138.         out[idx + 3] = alphabet[tmp & 0x3f]; 
139.         tmp >>= 6; 
140.         out[idx + 2] = alphabet[tmp & 0x3f]; 
141.         tmp >>= 6; 
142.         out[idx + 1] = alphabet[tmp & 0x3f]; 
143.         tmp >>= 6; 
144.         out[idx] = alphabet[tmp & 0x3f]; 
145.         idx += 4; 
146.          
147.         tmp = (int) (lsb & 0xff); 
148.         out[idx + 3] = alphabet[64]; 
149.         out[idx + 2] = alphabet[64]; 
150.         tmp <<= 4; 
151.         out[idx + 1] = alphabet[tmp & 0x3f]; 
152.         tmp >>= 6; 
153.         out[idx] = alphabet[tmp & 0x3f]; 
154.         idx += 4;*/  
155.           
156.         // 循环写法  
157.         int bit = 0, bt1 = 8, bt2 = 8;  
158.         int mask = 0x00, offsetm = 0, offsetl = 0;  
159.           
160.         for(; bit < 16; bit += 3, idx += 4) {  
161.             offsetm = 64 - (bit + 3) * 8;  
162.             offsetl = 0;  
163.             tmp = 0;  
164.               
165.             if(bt1 > 3) {  
166.                 mask = (1 << 8 * 3) - 1;  
167.             } else if(bt1 >= 0) {  
168.                 mask = (1 << 8 * bt1) - 1;  
169.                 bt2 -= 3 - bt1;  
170.             } else {  
171.                 mask = (1 << 8 * ((bt2 > 3) ? 3 : bt2)) - 1;  
172.                 bt2 -= 3;  
173.             }  
174.             if(bt1 > 0) {  
175.                 bt1 -= 3;  
176.                 tmp = (int) ((offsetm < 0) ? msb : (msb >>> offsetm) & mask);  
177.                 if(bt1 < 0) {  
178.                     tmp <<= Math.abs(offsetm);  
179.                     mask = (1 << 8 * Math.abs(bt1)) - 1;  
180.                 }  
181.             }  
182.             if(offsetm < 0) {  
183.                 offsetl = 64 + offsetm;  
184.                 tmp |= ((offsetl < 0) ? lsb : (lsb >>> offsetl)) & mask;  
185.             }  
186.               
187.             if(bit == 15) {  
188.                 out[idx + 3] = alphabet[64];  
189.                 out[idx + 2] = alphabet[64];  
190.                 tmp <<= 4;  
191.             } else {  
192.                 out[idx + 3] = alphabet[tmp & 0x3f];  
193.                 tmp >>= 6;  
194.                 out[idx + 2] = alphabet[tmp & 0x3f];  
195.                 tmp >>= 6;  
196.             }  
197.             out[idx + 1] = alphabet[tmp & 0x3f];  
198.             tmp >>= 6;  
199.             out[idx] = alphabet[tmp & 0x3f];  
200.         }  
201.           
202.         return new String(out, 0, 22);  
203.     }  
204. }  

其中，//注释的代码是测试代码和部分注释。/**/注释的是最简单的写法，等价于下面的for循环写法。只是自己看着不“优雅”改了。

经过测试，改造完的getUUID22方法生成字符串的速度，比原生的UUID.randomUUID().toString()方法快，在100W次的测试中，输出是时间大概是原生1850+ms:改造1040+ms的速度。

究其原因，应该是toString()方法拼接字符串"-"导致速度慢了。拼接字符串用+一般比较没效率。

 

结果：自己改造代码的过程比较纠结，写for循环总是卡死在某一步骤，最后把自己“变傻”，模仿计算机思维一步一步来就写出来了。就是不知道有没有更好的写法 。如有更好的写法请指教。