程序博客网 > 淘宝如何开通微淘

Java生成UUID

来源：互联网 发布：淘宝如何开通微淘 编辑：程序博客网 时间：2024/06/08 11:29

UUID含义是通用唯一识别码 (Universally Unique Identifier)，这 是一个软件建构的标准，也是被开源软件基金会 (Open Software Foundation, OSF) 的组织在分布式计算环境 (Distributed Computing Environment, DCE) 领域的一部份。UUID 的目的，是让分布式系统中的所有元素，都能有唯一的辨识资讯，而不需要透过中央控制端来做辨识资讯的指定。如此一来，每个人都可以建立不与其它人冲突的 UUID。在这样的情况下，就不需考虑数据库建立时的名称重复问题。目前最广泛应用的 UUID，即是微软的 Microsoft's Globally Unique Identifiers (GUIDs)，而其他重要的应用，则有 Linux ext2/ext3 档案系统、LUKS 加密分割区、GNOME、KDE、Mac OS X 等等。

以下是具体生成UUID的例子：

[java] view plain copy print?
  1. import java.util.UUID;    
  2.   
  3. public class UUIDGenerator {    
  4.     public UUIDGenerator() {    
  5.     }    
  6.     
  7.     public static String getUUID() {  
  8.         UUID uuid = UUID.randomUUID();  
  9.         String str = uuid.toString();  
  10.         // 去掉"-"符号  
  11.         String temp = str.substring(0, 8) + str.substring(9, 13) + str.substring(14, 18)   
  12.                 + str.substring(19, 23) + str.substring(24);  
  13.         return str+","+temp;  
  14.     }  
  15.     //获得指定数量的UUID  
  16.     public static String[] getUUID(int number) {  
  17.         if (number < 1) {  
  18.             return null;  
  19.         }  
  20.         String[] ss = new String[number];  
  21.         for (int i = 0; i < number; i++) {  
  22.             ss[i] = getUUID();  
  23.         }  
  24.         return ss;  
  25.     }    
  26.     
  27.     public static void main(String[] args) {    
  28.         String[] ss = getUUID(10);    
  29.         for (int i = 0; i < ss.length; i++) {    
  30.             System.out.println("ss["+i+"]====="+ss[i]);    
  31.         }    
  32.     }    
  33. }  

结果：
[plain] view plain copy print?
  1. ss[0]=====f6d1836d-1e3e-4d77-ab7c-54e177e689e5,f6d1836d1e3e4d77ab7c54e177e689e5  
  2. ss[1]=====8f122f82-d5dd-41df-826f-c83aa82bf1d2,8f122f82d5dd41df826fc83aa82bf1d2  
  3. ss[2]=====f7544ca0-c229-497f-973d-08743c8b54df,f7544ca0c229497f973d08743c8b54df  
  4. ss[3]=====54fbda9b-bb7e-46d5-8d07-21d69efe9ad7,54fbda9bbb7e46d58d0721d69efe9ad7  
  5. ss[4]=====1fc0ea43-b4f4-4aeb-b863-80dceec4c7e6,1fc0ea43b4f44aebb86380dceec4c7e6  
  6. ss[5]=====0051eecf-0168-43b1-86b3-442688989288,0051eecf016843b186b3442688989288  
  7. ss[6]=====d80a7016-14de-4f65-98da-435a062bd538,d80a701614de4f6598da435a062bd538  
  8. ss[7]=====16918380-c94c-4fbe-90f6-b3dbe2f31000,16918380c94c4fbe90f6b3dbe2f31000  
  9. ss[8]=====3f9a0bc1-fe4d-48fd-9d6a-da82630f9fbf,3f9a0bc1fe4d48fd9d6ada82630f9fbf  
  10. ss[9]=====0afa93eb-a89a-47d2-9590-4d3f194febe9,0afa93eba89a47d295904d3f194febe9  
        可以看出，UUID 是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。通常平台会提供生成的API。按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字
　　UUID由以下几部分的组合：
　　（1）当前日期和时间，UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同。
　　（2）时钟序列
　　（3）全局唯一的IEEE机器识别号，如果有网卡，从网卡MAC地址获得，没有网卡以其他方式获得。
　　UUID的唯一缺陷在于生成的结果串会比较长。关于UUID这个标准使用最普遍的是微软的GUID(Globals Unique Identifiers)。在ColdFusion中可以用CreateUUID()函数很简单的生成UUID，其格式为：xxxxxxxx-xxxx- xxxx-xxxxxxxxxxxxxxxx(8-4-4-16)，其中每个 x 是 0-9 或 a-f 范围内的一个十六进制的数字。而标准的UUID格式为：xxxxxxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxx (8-4-4-4-12)，可以从cflib 下载CreateGUID() UDF进行转换。
　　使用UUID的好处在分布式的软件系统中（比如：DCE/RPC, COM+,CORBA）就能体现出来，它能保证每个节点所生成的标识都不会重复，并且随着WEB服务等整合技术的发展，UUID的优势将更加明显。根据使用的特定机制，UUID不仅需要保证是彼此不相同的，或者最少也是与公元3400年之前其他任何生成的通用惟一标识符有非常大的区别。
　　通用惟一标识符还可以用来指向大多数的可能的物体。微软和其他一些软件公司都倾向使用全球惟一标识符（GUID），这也是通用惟一标识符的一种类型，可用来指向组建对象模块对象和其他的软件组件。第一个通用惟一标识符是在网罗计算机系统（NCS）中创建，并且随后成为开放软件基金会（OSF）的分布式计算环境（DCE）的组件。

以上内容转载自：http://blog.csdn.net/carefree31441/article/details/3998553


uuid 长度处理

[java] view plain copy print?
  1. import java.io.FileWriter;  
  2. import java.io.IOException;  
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5. import java.util.UUID;  
  6.   
  7. /** 
  8.  * @description: <br/> 
  9.  * @package test.AA.java 
  10.  * @author YangPu 
  11.  * @date 2016年11月3日 下午3:38:34 
  12.  */  
  13. public class AA {  
  14.   
  15.     private static final String fileName = "D:/out.txt";  
  16.   
  17.     private static final String[] chars = { // <br>  
  18.             "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", // <br>  
  19.             "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", // <br>  
  20.             "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", // <br>  
  21.             "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", // <br>  
  22.             "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", // <br>  
  23.             "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", // <br>  
  24.             "Y", "Z", "a1", "a2" // <br>  
  25.     };  
  26.   
  27.     // 统计UUID的长度变化范围  
  28.     public static void main(String[] args) throws InterruptedException {  
  29.         int time = 1 * 10000 * 1;  
  30.         for (int j = 0; j < 15; j++) {  
  31.             Map<Integer, Integer> sum = new HashMap<>();  
  32.             Map<String, Integer> sumStr = new HashMap<>();  
  33.             for (int ii = 0; ii < time; ii++) {  
  34.                 String uuid = uuid(j);  
  35.                 int sbLength = uuid.length();  
  36.                 String sb = uuid.substring(0, 1);  
  37.                 if (sum.get(Integer.valueOf(sbLength)) != null) {  
  38.                     int v = sum.get(Integer.valueOf(sbLength)).intValue();  
  39.                     v++;  
  40.                     sum.put(Integer.valueOf(sbLength), v);  
  41.                 } else {  
  42.                     sum.put(Integer.valueOf(sbLength), 1);  
  43.                 }  
  44.                 if (sumStr.get(sb) != null) {  
  45.                     int v = sumStr.get(sb).intValue();  
  46.                     v++;  
  47.                     sumStr.put(sb, v);  
  48.                 } else {  
  49.                     sumStr.put(sb, 1);  
  50.                 }  
  51.             }  
  52.             write("j：" + j);  
  53.             for (Integer in : sum.keySet()) {  
  54.                 write(in + "：" + sum.get(in));  
  55.                 // System.out.println(in + "：" + sum.get(in));  
  56.             }  
  57.         }  
  58.     }  
  59.   
  60.     /** 
  61.      * @description: 生成UUID<br/> 
  62.      *               可以确定开头字母来区别业务<br/> 
  63.      *               num16：必须是0--15以内的数字<br/> 
  64.      *               @param：num16：<br/> 
  65.      *               00-->>"0", "1", "2", "3",<br/> 
  66.      *               01-->>"4", "5", "6", "7",<br/> 
  67.      *               02-->>"8", "9", "a", "b",<br/> 
  68.      *               03-->>"c", "d", "e", "f",<br/> 
  69.      *               04-->>"g", "h", "i", "j",<br/> 
  70.      *               05-->>"k", "l", "m", "n",<br/> 
  71.      *               06-->>"o", "p", "q", "r",<br/> 
  72.      *               07-->>"s", "t", "u", "v",<br/> 
  73.      *               08-->>"w", "x", "y", "z",<br/> 
  74.      *               09-->>"A", "B", "C", "D",<br/> 
  75.      *               10-->>"E", "F", "G", "H",<br/> 
  76.      *               11-->>"I", "J", "K", "L",<br/> 
  77.      *               12-->>"M", "N", "O", "P",<br/> 
  78.      *               13-->>"Q", "R", "S", "T",<br/> 
  79.      *               14-->>"U", "V", "W", "X",<br/> 
  80.      */  
  81.     public static String uuid(int num16) {  
  82.         if (num16 < 0 || num16 > 15) {  
  83.             num16 = 0;  
  84.         }  
  85.         StringBuilder sb = new StringBuilder();  
  86.         String pre = Integer.toHexString(num16);  
  87.         String uid = pre + UUID.randomUUID().toString().replaceAll("-", "");  
  88.         int length = uid.length();  
  89.         // 将16进制数转换成64进制数  
  90.         // 2的4次方转化成2的6次方的数据  
  91.         // bcb da5 f41 172 4bc 28b 920 b1c 5f4 422 6e  
  92.         // 3位转2位  
  93.         int i = 0;  
  94.         for (; i < length; i = i + 3) {  
  95.             // 16进制数转化成10进制数  
  96.             int end = i + 3;  
  97.             if (end >= length) {  
  98.                 end = length;  
  99.             }  
  100.             int t = Integer.parseInt(uid.substring(i, end), 16);  
  101.             // 10进制数转化成64进制数  
  102.             sb.append(chars[t / 64]);// 第一个数据  
  103.             sb.append(chars[t % 64]);// 第二个数据  
  104.         }  
  105.         // write(sb.toString().substring(0, 1) + "----" + sb.toString());  
  106.         write(sb);  
  107.         // System.out.println(sb);  
  108.         return sb.toString();  
  109.     }  
  110.   
  111.     public static void write(Object out) {  
  112.         if (out == null) {  
  113.             return;  
  114.         }  
  115.         try {  
  116.             // 打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件  
  117.             FileWriter writer = new FileWriter(fileName, true);  
  118.             writer.write(out.toString() + "\n");  
  119.             writer.close();  
  120.         } catch (IOException e) {  
  121.             // TODO Auto-generated catch block  
  122.             e.printStackTrace();  
  123.         }  
  124.     }  
  125. }  
运行代码会在D盘中生成out.txt文件，内容如下：
[plain] view plain copy print?
  1. 1XG6g0rfV5uo57vpNEvE4f  
  2. 0hQXkufT9aXX00ZF0UcYqp  
  3. 1zVt11eDhcaUa2QekcJEWdE  
  4. 3C27deVa1h4cbTJPAXXIgBE  
  5. 0fF4UvtpB4695fswmw68lg  
  6. 2SvWeEOAp9WVcEpXWOuX8B  
  7. 0U7eE1kyF7iqI0XP59iqxY  
  8. 0hsS1rzP10jVa2RjSzo6g1d  
  9. 2tSeCGCvB2ja1mAt0PjYjn  
  10. 。。。。。。  
以上内容来自：http://blog.csdn.net/want_water_fish/article/details/67638195


JAVA生成短8位UUID

短8位UUID思想其实借鉴微博短域名的生成方式，但是其重复概率过高，而且每次生成4个，需要随即选取一个。
本算法利用62个可打印字符，通过随机生成32位UUID，由于UUID都为十六进制，所以将UUID分成8组，每4个为一组，然后通过模62操作，结果作为索引取出字符，
这样重复率大大降低。

[java] view plain copy print?
  1. import java.util.UUID;  
  2.   
  3. public class hui {  
  4.     public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f",  
  5.         "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",  
  6.         "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",  
  7.         "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",  
  8.         "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",  
  9.         "W", "X", "Y", "Z" };  
  10.   
  11.   
  12.     public static String generateShortUuid() {  
  13.     StringBuffer shortBuffer = new StringBuffer();  
  14.     String uuid = UUID.randomUUID().toString().replace("-", "");  
  15.     for (int i = 0; i < 8; i++) {  
  16.         String str = uuid.substring(i * 4, i * 4 + 4);  
  17.         int x = Integer.parseInt(str, 16);  
  18.         shortBuffer.append(chars[x % 0x3E]);  
  19.     }  
  20.     System.out.println(shortBuffer.toString());  
  21.     return shortBuffer.toString();  
  22.     }  
  23.     public static void main(String args[]){  
  24.         generateShortUuid();  
  25.     }  
  26. }  
运行这个代码会随机生成一个8位的UUID，如我的运行结果为：cgsnjhN9


以上内容来自http://www.oschina.net/code/snippet_1431757_50945，在评论区有人编写了测试重复率有多大的代码，感觉不错就粘贴了下来：

[java] view plain copy print?
  1. import java.util.HashSet;  
  2. import java.util.Set;  
  3. import java.util.UUID;  
  4.   
  5. public class SerialNo {  
  6.   
  7.     public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",  
  8.         "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7",  
  9.         "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S",  
  10.         "T", "U", "V", "W", "X", "Y", "Z" };  
  11.   
  12.     public static String generateShortUuid() {  
  13.         StringBuffer shortBuffer = new StringBuffer();  
  14.         String uuid = UUID.randomUUID().toString().replace("-", "");  
  15.         for (int i = 0; i < 8; i++) {  
  16.             String str = uuid.substring(i * 4, i * 4 + 4);  
  17.             int x = Integer.parseInt(str, 16);  
  18.             shortBuffer.append(chars[x % 0x3E]);  
  19.         }  
  20.         return shortBuffer.toString();  
  21.     }  
  22.   
  23.     /** 
  24.      * @title main 
  25.      * @date 2015-10-14 下午3:05:17 
  26.      * @since 2015-10-14 
  27.      * @version v1.0.0 
  28.      * @param args 
  29.      * @throws InterruptedException  
  30.      */  
  31.     public static void main(String[] args) throws InterruptedException {  
  32.         final int num = 1000000; // 1,000,000  
  33.         final Set<String> rs_set = new HashSet<String>();  
  34.   
  35.         new Thread(new Runnable() {   
  36.             @Override  
  37.             public void run() {  
  38.                 Set<String> set = new HashSet<String>();  
  39.                 for (int i = 0; i < num; i++) {  
  40.                     set.add(SerialNo.generateShortUuid());  
  41.                 }  
  42.                 System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size()   
  43.                         + " &Repeated Count:" + (num - set.size()));  
  44.                 rs_set.addAll(set);  
  45.             }  
  46.         }).start();  
  47.         new Thread(new Runnable() {   
  48.             @Override  
  49.             public void run() {  
  50.                 Set<String> set = new HashSet<String>();  
  51.                 for (int i = 0; i < num; i++) {  
  52.                     set.add(SerialNo.generateShortUuid());  
  53.                 }  
  54.                 System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size()   
  55.                         + " &Repeated Count:" + (num - set.size()));  
  56.                 rs_set.addAll(set);  
  57.             }  
  58.         }).start();  
  59.         new Thread(new Runnable() {   
  60.             @Override  
  61.             public void run() {  
  62.                 Set<String> set = new HashSet<String>();  
  63.                 for (int i = 0; i < num; i++) {  
  64.                     set.add(SerialNo.generateShortUuid());  
  65.                 }  
  66.                 System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size()   
  67.                         + " &Repeated Count:" + (num - set.size()));  
  68.                 rs_set.addAll(set);  
  69.             }  
  70.         }).start();  
  71.         new Thread(new Runnable() {   
  72.             @Override  
  73.             public void run() {  
  74.                 Set<String> set = new HashSet<String>();  
  75.                 for (int i = 0; i < num; i++) {  
  76.                     set.add(SerialNo.generateShortUuid());  
  77.                 }  
  78.                 System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size()   
  79.                         + " &Repeated Count:" + (num - set.size()));  
  80.                 rs_set.addAll(set);  
  81.             }  
  82.         }).start();  
  83.   
  84.         Thread.sleep(1000 * 60 * 3);  
  85.         System.out.println("Final Release RS||" + "Rs_Count:" + rs_set.size()   
  86.                 + " &Repeated Count:" + ((num * 4) - rs_set.size()));  
  87.     }  
  88. }  

我的运行结果是（运行这个程序即使结果已经打出程序也没有退出，我感觉他的代码还有需要完善的地方，有时间再看看吧）：

[plain] view plain copy print?
  1. Thread-1Rs_Count:1000000 &Repeated Count:0  
  2. Thread-2Rs_Count:1000000 &Repeated Count:0  
  3. Thread-0Rs_Count:1000000 &Repeated Count:0  
  4. Thread-3Rs_Count:1000000 &Repeated Count:0  
  5. Final Release RS||Rs_Count:276429 &Repeated Count:3723571  
阅读全文
0 0
淘宝如何开通微淘 淘宝如何开通微淘
原创粉丝点击
热门IT博客
知敬畏守规矩讨论稿知敬畏守规矩讨论稿
深入java虚拟机电子书深入java虚拟机电子书
npm node sass 淘宝
php后端登录代码
电子数据取证软件
嫁给富二代知乎
4i网络整合营销理论
python 执行adb
java u003d
密子君淘宝店
网络歌手翻唱
达索delmia软件
批发网络摄像头
mac 搜狗输入法 流氓
python .dot
网络推广的100种方法
个人主页静态网页源码
python安装提示错误
重庆影视频道网络播放
已知子网掩码求网络
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 怎么样去爱一个人 什么叫爱情 爱出色 爱的歌曲大全 aiba 找爱吧 爱的含义 爱繁体字 爱情的图片 爱英文 如何让一个人爱上你 情感故事大全伤感 爱的照片 有爱就可以 如何去爱一个女孩 歌曲爱 aini 怎么去爱一个女孩 爱情的歌词 爱上一个人怎么办 爱一个 如何爱 爱手语 如何去爱一个女人 爱与诚 爱 图片 爱在网 爱是什么意思 爱的意思 爱的体验 怎样爱一个人 爱的含义是什么 爱在这儿 我爱资源 我爱资源网 爱资源网 爱收集资源网 爱资源 爱qq爱生活 爱qq生活网 爱q网

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里