精华内容
下载资源
问答
  • java 生成uuid

    万次阅读 2019-06-11 17:12:07
    1.UUID 简介 UUID 含义是通用唯一识别码 (Universally Unique Identifier),这是一个软件建构的标准。 也是被开源软件基金会 (Open Software Foundation, OSF)的组织应用在分布式计算环境 (Distributed ...

    1.UUID 简介

       UUID 含义是通用唯一识别码 (Universally Unique Identifier),这是一个软件建构的标准。

       也是被开源软件基金会 (Open Software Foundation, OSF) 的组织应用在分布式计算环境 (Distributed Computing Environment, DCE) 领域的一部分。

       UUID 的目的,是让分布式系统中的所有元素,都能有唯一的辨识资讯,而不需要透过中央控制端来做辨识资讯的指定。

       如此一来,每个人都可以建立不与其它人冲突的 UUID。在这样的情况下,就不需考虑数据库建立时的名称重复问题。

     

    2.UUID 组成

       UUID保证对在同一时空中的所有机器都是唯一的。通常平台会提供生成的API。

       按照开放软件基金会(OSF)制定的标准计算,用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。

    UUID由以下几部分的组合:

    (1)当前日期和时间,UUID的第一个部分与时间有关,如果你在生成一个UUID之后,过几秒又生成一个UUID,则第一个部分不同,其余相同。

    (2)时钟序列。

    (3)全局唯一的IEEE机器识别号,如果有网卡,从网卡MAC地址获得,没有网卡以其他方式获得。

       UUID的唯一缺陷在于生成的结果串会比较长。关于UUID这个标准使用最普遍的是微软的GUID(Globals Unique Identifiers)。

     

    代码:

    /** 
     * Project Name:rabbitMQ 
     * File Name:UUIDUtils.java 
     * Package Name:com.tang.common 
     * Date:2019年6月11日 下午4:59:20 
     * 
     * 
     */
    package com.tang.common;
    
    import java.util.UUID;
    
    /** 
     * ClassName: UUIDUtils
     * Function: 生成uuid
     * date: 2019年6月11日 下午4:59:20
     * 
     * @author tangjiandong
     */
    public class UUIDUtils {
    	
    	
    	/**
    	 *32位默认长度的uuid 
    	 * (获取32位uuid)
    	 * 
    	 * @return
    	 */
    	public static  String getUUID()
    	{
    		return UUID.randomUUID().toString().replace("-", "");
    	}
    	
    	
    
    	
    }
    

     

     

    展开全文
  • 主要介绍了浅谈JAVA如何生成UUID唯一标识,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java生成uuid_Java UUID

    千次阅读 2021-01-05 16:06:46
    java生成uuid介绍: UUID(通用唯一标识符)表示一个128位长的唯一值。 它也被普遍称为GUID(全球唯一标识符)。 UUID的标准表示形式由十六进制数字组成: 533a4559-e55c-18b3-8456-555563322002并具有36个字符,其中...
    java生成uuid

    java生成uuid

    介绍:

    UUID(通用唯一标识符)表示一个128位长的唯一值。 它也被普遍称为GUID(全球唯一标识符)。

    UUID的标准表示形式由十六进制数字组成:

    533a4559-e55c-18b3-8456-555563322002

    并具有36个字符,其中包括四个连字符'-'

    Java中的java.util.UUID类表示一个不变的UUID。

    我们可以使用UUID类来生成随机文件名,会话或事务ID。 UUID的另一种流行用法是在数据库中生成主键值。

    Java UUID类具有一种用于处理Leach-Salz变体(变体2)的方法。 但是,其构造函数允许生成任何类型的UUID

    new UUID(long mostSigBits, long leastSigBits)

    一个变体确定UUID的布局。 让我们来一个样本UUID

    533a4559-e55c-18b3-8456-555563322002
    xxxxxxxx-xxxx-Bxxx-Axxx-xxxxxxxxxxxx

    此处, A的值表示变量,并由其前三个MSB(最高有效位)确定:

    MSB1 MSB2 MSB3 变体 变体说明
    0 X X 0 保留用于NCS向后兼容
    1个0 X 2 里奇-萨尔茨
    1个1个0 6 保留,Microsoft Corporation向后兼容
    1个1个7 保留以供将来定义

    对于我们来说, A = 8(1000) ,因此前三个MSB100 。 这意味着我们的UUID具有2的变体。

    对于版本2 UUID ,有五个不同的版本:

    描述
    v1 基于时间的
    v2 DCE-安全
    v3和v5 基于名称
    v4 随机生成的UUID

    生成

    让我们介绍一下Java UUID类中的方法,这些方法可用于生成UUID

    1.

    使用加密强度高的伪随机数生成器生成v4伪随机UUID

    UUID uuid = UUID.randomUUID();

    2.

    我们可以使用nameUUIDFromBytes()从字节数组生成UUID

    byte[] byteArr = {11, 23, 33}; 
    UUID uuid = UUID.nameUUIDFromBytes(byteArr);

    此方法生成v3 UUID (基于名称)。

    3.

    使用fromString() ,我们可以从标准字符串表示形式创建UUID

    UUID uuid = UUID.fromString("533a4559-e55c-18b3-2456-555563322002");

    对于作为参数传入的任何无效字符串,它将引发IllegalArgumentException

    比较两个

    Java UUID类实现Comparable接口。 因此,我们可以使用compareTo()方法进行比较:

    UUID uuid1 = UUID.randomUUID();
    UUID uuid2 = UUID.randomUUID();
     
    int result = uuid1.compareTo(uuid2);

    众所周知, compareTo()方法返回:

    • 1:如果uuid1大于uuid2
    • 0:如果uuid1 = uuid2
    • -1:如果uuid1小于uuid2

    我们也可以选择使用equals()方法进行比较。

    其他方法:

    让我们介绍一下Java UUID类的其他一些方法:

    1.

    顾名思义, getLeastSignificantBits()getMostSignificantBits()分别返回64个最低有效位和64个最高有效位

    UUID uuid = UUID.randomUUID();
     
    long leastSignificantBits = uuid.getLeastSignificantBits();
    long mostSignificantBits = uuid.getMostSignificantBits();

    这两种方法都返回一个long值。

    2.

    我们还可以查询UUID的变体和版本

    UUID uuid = UUID.randomUUID();
     
    int variant = uuid.variant();
    int version = uuid.version();

    使用基于时间的

    让我们从在POM中java- uuid -generator添加一个依赖关系开始:

    <dependency>
        <groupId>com.fasterxml.uuid</groupId>
        <artifactId>java-uuid-generator</artifactId>
        <version>3.1.5</version>
    </dependency>

    请注意,该库提供了各种类型的UUID生成器。

    要创建基于时间的UUID ,我们将具有:

    UUID uuid = Generators.timeBasedGenerator().generate();

    处理v1 UUID时,方便使用的java.util包中的其他方法包括:

    1. timestamp():返回与给定的v1 UUID关联的时间戳值。 与任何其他类型的UUID一起使用时,此方法将引发UnsupportedOperationException

    2. clockSequence():它返回一个14位值,该值由给定UUID的时钟序列字段构成。 它还会为v1类型以外的UUID抛出UnsupportedOperationException

    结论:

    在本教程中,我们了解了什么是UUID及其变体。 我们讨论了变量类型2的不同可用版本。 我们还介绍了Java UUID类公开的许多方法。

    翻译自: https://www.javacodegeeks.com/2019/03/java-uuid.html

    java生成uuid

    展开全文
  • java生成UUID

    千次阅读 2017-07-15 14:34:50
    GUID是一个128位长的数字,一般用16进制表示。算法的核心思想是结合机器的网卡、当地时间、一...UUID是1.5中新增的一个类,在java.util下,用它可以产生一个号称全球唯一的ID package com.mytest; import java.util.UU

    在java中生成UUID

    GUID是一个128位长的数字,一般用16进制表示。算法的核心思想是结合机器的网卡、当地时间、一个随即数来生成GUID。从理论上讲,如果一台机器每秒产生10000000个GUID,则可以保证(概率意义上)3240年不重复。

    UUID是1.5中新增的一个类,在java.util下,用它可以产生一个号称全球唯一的ID

    package com.mytest;

    import java.util.UUID;

    public class UTest {
        public static void main(String[] args) {
            UUID uuid = UUID.randomUUID();
            System.out.println(uuid);
        }
    }


    UUID(Universally Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字,它保证对在同一时空中的所有机器都是唯一的。按照开放软件基金会(OSF)制定的标准计算,用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。由以下几部分的组合:当前日期和时间(UUID的第一个部分与时间有关,如果你在生成一个UUID之后,过几秒又生成一个UUID,则第一个部分不同,其余相同),时钟序列,全局唯一的IEEE机器识别号(如果有网卡,从网卡获得,没有网卡以其他方式获得),UUID的唯一缺陷在于生成的结果串会比较长。 
    Java中生成UUID主要有以下几种方式: 

    JDK1.5 
    如果使用的JDK1.5的话,那么生成UUID变成了一件简单的事,以为JDK实现了UUID: 
    java.util.UUID,直接调用即可. 
    UUID uuid  =  UUID.randomUUID(); 
    String s = UUID.randomUUID().toString();//用来生成数据库的主键id非常不错。。   

    UUID是由一个十六位的数字组成,表现出来的形式例如 
    550E8400-E29B-11D4-A716-446655440000   

    //下面就是实现为数据库获取一个唯一的主键id的代码 
    public class UUIDGenerator { 
        public UUIDGenerator() { 
        } 
        /** 
         * 获得一个UUID 
         * @return String UUID 
         */ 
        public static String getUUID(){ 
            String s = UUID.randomUUID().toString(); 
            //去掉“-”符号 
            return s.substring(0,8)+s.substring(9,13)+s.substring(14,18)+s.substring(19,23)+s.substring(24); 
        } 
        /** 
         * 获得指定数目的UUID 
         * @param number int 需要获得的UUID数量 
         * @return String[] UUID数组 
         */ 
        public static String[] getUUID(int number){ 
            if(number < 1){ 
                return null; 
            } 
            String[] ss = new String[number]; 
            for(int i=0;i<number;i++){ 
                ss[i] = getUUID(); 
            } 
            return ss; 
        } 
        public static void main(String[] args){ 
            String[] ss = getUUID(10); 
            for(int i=0;i<ss.length;i++){ 
                System.out.println(ss[i]); 
            } 
        } 
    }   


    两种方式生成guid 与uuid

    需要comm log 库

    /**
     * @author Administrator
     *
     * TODO To change the template for this generated type comment go to
     * Window - Preferences - Java - Code Style - Code Templates
     */
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.Random;

    public class RandomGUID extends Object {
       protected final org.apache.commons.logging.Log logger = org.apache.commons.logging.LogFactory
          .getLog(getClass());

       public String valueBeforeMD5 = "";
       public String valueAfterMD5 = "";
       private static Random myRand;
       private static SecureRandom mySecureRand;

       private static String s_id;
       private static final int PAD_BELOW = 0x10;
       private static final int TWO_BYTES = 0xFF;

       /*
        * Static block to take care of one time secureRandom seed.
        * It takes a few seconds to initialize SecureRandom.  You might
        * want to consider removing this static block or replacing
        * it with a "time since first loaded" seed to reduce this time.
        * This block will run only once per JVM instance.
          */

       static {
          mySecureRand = new SecureRandom();
          long secureInitializer = mySecureRand.nextLong();
          myRand = new Random(secureInitializer);
          try {
             s_id = InetAddress.getLocalHost().toString();
          } catch (UnknownHostException e) {
             e.printStackTrace();
          }

       }


       /*
        * Default constructor.  With no specification of security option,
        * this constructor defaults to lower security, high performance.
        */
       public RandomGUID() {
          getRandomGUID(false);
       }

       /*
        * Constructor with security option.  Setting secure true
        * enables each random number generated to be cryptographically
        * strong.  Secure false defaults to the standard Random function seeded
        * with a single cryptographically strong random number.
        */
       public RandomGUID(boolean secure) {
          getRandomGUID(secure);
       }

       /*
        * Method to generate the random GUID
        */
       private void getRandomGUID(boolean secure) {
          MessageDigest md5 = null;
          StringBuffer sbValueBeforeMD5 = new StringBuffer(128);

          try {
             md5 = MessageDigest.getInstance("MD5");
          } catch (NoSuchAlgorithmException e) {
             logger.error("Error: " + e);
          }

          try {
             long time = System.currentTimeMillis();
             long rand = 0;

             if (secure) {
                rand = mySecureRand.nextLong();
             } else {
                rand = myRand.nextLong();
             }
             sbValueBeforeMD5.append(s_id);
             sbValueBeforeMD5.append(":");
             sbValueBeforeMD5.append(Long.toString(time));
             sbValueBeforeMD5.append(":");
             sbValueBeforeMD5.append(Long.toString(rand));

             valueBeforeMD5 = sbValueBeforeMD5.toString();
             md5.update(valueBeforeMD5.getBytes());

             byte[] array = md5.digest();
             StringBuffer sb = new StringBuffer(32);
             for (int j = 0; j < array.length; ++j) {
                int b = array[j] & TWO_BYTES;
                if (b < PAD_BELOW)
                   sb.append('0');
                sb.append(Integer.toHexString(b));
             }

             valueAfterMD5 = sb.toString();

          } catch (Exception e) {
             logger.error("Error:" + e);
          }
       }

       /*
        * Convert to the standard format for GUID
        * (Useful for SQL Server UniqueIdentifiers, etc.)
        * Example: C2FEEEAC-CFCD-11D1-8B05-00600806D9B6
        */
       public String toString() {
          String raw = valueAfterMD5.toUpperCase();
          StringBuffer sb = new StringBuffer(64);
          sb.append(raw.substring(0, 8));
          sb.append("-");
          sb.append(raw.substring(8, 12));
          sb.append("-");
          sb.append(raw.substring(12, 16));
          sb.append("-");
          sb.append(raw.substring(16, 20));
          sb.append("-");
          sb.append(raw.substring(20));

          return sb.toString();
       }


         // Demonstraton and self test of class
         public static void main(String args[]) {
           for (int i=0; i< 100; i++) {
             RandomGUID myGUID = new RandomGUID();
             System.out.println("Seeding String=" + myGUID.valueBeforeMD5);
             System.out.println("rawGUID=" + myGUID.valueAfterMD5);
             System.out.println("RandomGUID=" + myGUID.toString());
           }
         }


    }

    同样

    UUID uuid = UUID.randomUUID();
    System.out.println("{"+uuid.toString()+"}");

    UUID是指在一台机器上生成的数字,它保证对在同一时空中的所有机器都是唯一的。通常平台会提供生成UUID的API。UUID按照开放软件基金会(OSF)制定的标准计算,用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。由以下几部分的组合:当前日期和时间(UUID的第一个部分与时间有关,如果你在生成一个UUID之后,过几秒又生成一个UUID,则第一个部分不同,其余相同),时钟序列,全局唯一的IEEE机器识别号(如果有网卡,从网卡获得,没有网卡以其他方式获得),UUID的唯一缺陷在于生成的结果串会比较长。关于UUID这个标准使用最普遍的是微软的GUID(Globals Unique Identifiers)。

     

    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/xiajing12345/archive/2005/04/22/358976.aspx




    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的例子:

    view plaincopy to clipboardprint?
    package test;  
     
    import java.util.UUID;  
     
    public class UUIDGenerator {  
        public UUIDGenerator() {  
        }  
     
        public static String getUUID() {  
            UUID uuid = UUID.randomUUID();  
            String str = uuid.toString();  
            // 去掉"-"符号  
            String temp = str.substring(0, 8) + str.substring(9, 13) + str.substring(14, 18) + str.substring(19, 23) + str.substring(24);  
            return str+","+temp;  
        }  
        //获得指定数量的UUID  
        public static String[] getUUID(int number) {  
            if (number < 1) {  
                return null;  
            }  
            String[] ss = new String[number];  
            for (int i = 0; i < number; i++) {  
                ss[i] = getUUID();  
            }  
            return ss;  
        }  
     
        public static void main(String[] args) {  
            String[] ss = getUUID(10);  
            for (int i = 0; i < ss.length; i++) {  
                System.out.println("ss["+i+"]====="+ss[i]);  
            }  
        }  

    package test;

    import java.util.UUID;

    public class UUIDGenerator {
     public UUIDGenerator() {
     }

     public static String getUUID() {
      UUID uuid = UUID.randomUUID();
      String str = uuid.toString();
      // 去掉"-"符号
      String temp = str.substring(0, 8) + str.substring(9, 13) + str.substring(14, 18) + str.substring(19, 23) + str.substring(24);
      return str+","+temp;
     }
     //获得指定数量的UUID
     public static String[] getUUID(int number) {
      if (number < 1) {
       return null;
      }
      String[] ss = new String[number];
      for (int i = 0; i < number; i++) {
       ss[i] = getUUID();
      }
      return ss;
     }

     public static void main(String[] args) {
      String[] ss = getUUID(10);
      for (int i = 0; i < ss.length; i++) {
       System.out.println("ss["+i+"]====="+ss[i]);
      }
     }
    }

    结果:

    view plaincopy to clipboardprint?
    ss[0]=====4cdbc040-657a-4847-b266-7e31d9e2c3d9,4cdbc040657a4847b2667e31d9e2c3d9  
    ss[1]=====72297c88-4260-4c05-9b05-d28bfb11d10b,72297c8842604c059b05d28bfb11d10b  
    ss[2]=====6d513b6a-69bd-4f79-b94c-d65fc841ea95,6d513b6a69bd4f79b94cd65fc841ea95  
    ss[3]=====d897a7d3-87a3-4e38-9e0b-71013a6dbe4c,d897a7d387a34e389e0b71013a6dbe4c  
    ss[4]=====5709f0ba-31e3-42bd-a28d-03485b257c94,5709f0ba31e342bda28d03485b257c94  
    ss[5]=====530fbb8c-eec9-48d1-ae1b-5f792daf09f3,530fbb8ceec948d1ae1b5f792daf09f3  
    ss[6]=====4bf07297-65b2-45ca-b905-6fc6f2f39158,4bf0729765b245cab9056fc6f2f39158  
    ss[7]=====6e5a0e85-b4a0-485f-be54-a758115317e1,6e5a0e85b4a0485fbe54a758115317e1  
    ss[8]=====245accec-3c12-4642-967f-e476cef558c4,245accec3c124642967fe476cef558c4  
    ss[9]=====ddd4b5a9-fecd-446c-bd78-63b70bb500a1,ddd4b5a9fecd446cbd7863b70bb500a1 
    ss[0]=====4cdbc040-657a-4847-b266-7e31d9e2c3d9,4cdbc040657a4847b2667e31d9e2c3d9
    ss[1]=====72297c88-4260-4c05-9b05-d28bfb11d10b,72297c8842604c059b05d28bfb11d10b
    ss[2]=====6d513b6a-69bd-4f79-b94c-d65fc841ea95,6d513b6a69bd4f79b94cd65fc841ea95
    ss[3]=====d897a7d3-87a3-4e38-9e0b-71013a6dbe4c,d897a7d387a34e389e0b71013a6dbe4c
    ss[4]=====5709f0ba-31e3-42bd-a28d-03485b257c94,5709f0ba31e342bda28d03485b257c94
    ss[5]=====530fbb8c-eec9-48d1-ae1b-5f792daf09f3,530fbb8ceec948d1ae1b5f792daf09f3
    ss[6]=====4bf07297-65b2-45ca-b905-6fc6f2f39158,4bf0729765b245cab9056fc6f2f39158
    ss[7]=====6e5a0e85-b4a0-485f-be54-a758115317e1,6e5a0e85b4a0485fbe54a758115317e1
    ss[8]=====245accec-3c12-4642-967f-e476cef558c4,245accec3c124642967fe476cef558c4
    ss[9]=====ddd4b5a9-fecd-446c-bd78-63b70bb500a1,ddd4b5a9fecd446cbd7863b70bb500a1

      可以看出,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)的组件。

     

    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/carefree31441/archive/2009/03/17/3998553.aspx



    展开全文
  • Java生成UUID

    千次阅读 2017-11-20 16:48:05
    UUID含义是通用唯一识别码 (Universally Unique Identifier),这 是一个软件建构的标准,也是被开源软件基金会 (Open Software Foundation, OSF) 的组织在分布式计算环境 (Distributed Computing Environment, DCE) ...
            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的例子:

    import java.util.UUID;  
    
    public class UUIDGenerator {  
        public UUIDGenerator() {  
        }  
      
        public static String getUUID() {
            UUID uuid = UUID.randomUUID();
            String str = uuid.toString();
            // 去掉"-"符号
            String temp = str.substring(0, 8) + str.substring(9, 13) + str.substring(14, 18) 
            		+ str.substring(19, 23) + str.substring(24);
            return str+","+temp;
        }
        //获得指定数量的UUID
        public static String[] getUUID(int number) {
            if (number < 1) {
                return null;
            }
            String[] ss = new String[number];
            for (int i = 0; i < number; i++) {
                ss[i] = getUUID();
            }
            return ss;
        }  
      
        public static void main(String[] args) {  
            String[] ss = getUUID(10);  
            for (int i = 0; i < ss.length; i++) {  
                System.out.println("ss["+i+"]====="+ss[i]);  
            }  
        }  
    }

    结果:
    ss[0]=====f6d1836d-1e3e-4d77-ab7c-54e177e689e5,f6d1836d1e3e4d77ab7c54e177e689e5
    ss[1]=====8f122f82-d5dd-41df-826f-c83aa82bf1d2,8f122f82d5dd41df826fc83aa82bf1d2
    ss[2]=====f7544ca0-c229-497f-973d-08743c8b54df,f7544ca0c229497f973d08743c8b54df
    ss[3]=====54fbda9b-bb7e-46d5-8d07-21d69efe9ad7,54fbda9bbb7e46d58d0721d69efe9ad7
    ss[4]=====1fc0ea43-b4f4-4aeb-b863-80dceec4c7e6,1fc0ea43b4f44aebb86380dceec4c7e6
    ss[5]=====0051eecf-0168-43b1-86b3-442688989288,0051eecf016843b186b3442688989288
    ss[6]=====d80a7016-14de-4f65-98da-435a062bd538,d80a701614de4f6598da435a062bd538
    ss[7]=====16918380-c94c-4fbe-90f6-b3dbe2f31000,16918380c94c4fbe90f6b3dbe2f31000
    ss[8]=====3f9a0bc1-fe4d-48fd-9d6a-da82630f9fbf,3f9a0bc1fe4d48fd9d6ada82630f9fbf
    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 长度处理

    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.UUID;
    
    /**
     * @description: <br/>
     * @package test.AA.java
     * @author YangPu
     * @date 2016年11月3日 下午3:38:34
     */
    public class AA {
    
        private static final String fileName = "D:/out.txt";
    
        private static final String[] chars = { // <br>
                "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", // <br>
                "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", // <br>
                "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", // <br>
                "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", // <br>
                "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", // <br>
                "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", // <br>
                "Y", "Z", "a1", "a2" // <br>
        };
    
        // 统计UUID的长度变化范围
        public static void main(String[] args) throws InterruptedException {
            int time = 1 * 10000 * 1;
            for (int j = 0; j < 15; j++) {
                Map<Integer, Integer> sum = new HashMap<>();
                Map<String, Integer> sumStr = new HashMap<>();
                for (int ii = 0; ii < time; ii++) {
                    String uuid = uuid(j);
                    int sbLength = uuid.length();
                    String sb = uuid.substring(0, 1);
                    if (sum.get(Integer.valueOf(sbLength)) != null) {
                        int v = sum.get(Integer.valueOf(sbLength)).intValue();
                        v++;
                        sum.put(Integer.valueOf(sbLength), v);
                    } else {
                        sum.put(Integer.valueOf(sbLength), 1);
                    }
                    if (sumStr.get(sb) != null) {
                        int v = sumStr.get(sb).intValue();
                        v++;
                        sumStr.put(sb, v);
                    } else {
                        sumStr.put(sb, 1);
                    }
                }
                write("j:" + j);
                for (Integer in : sum.keySet()) {
                    write(in + ":" + sum.get(in));
                    // System.out.println(in + ":" + sum.get(in));
                }
            }
        }
    
        /**
         * @description: 生成UUID<br/>
         *               可以确定开头字母来区别业务<br/>
         *               num16:必须是0--15以内的数字<br/>
         *               @param:num16:<br/>
         *               00-->>"0", "1", "2", "3",<br/>
         *               01-->>"4", "5", "6", "7",<br/>
         *               02-->>"8", "9", "a", "b",<br/>
         *               03-->>"c", "d", "e", "f",<br/>
         *               04-->>"g", "h", "i", "j",<br/>
         *               05-->>"k", "l", "m", "n",<br/>
         *               06-->>"o", "p", "q", "r",<br/>
         *               07-->>"s", "t", "u", "v",<br/>
         *               08-->>"w", "x", "y", "z",<br/>
         *               09-->>"A", "B", "C", "D",<br/>
         *               10-->>"E", "F", "G", "H",<br/>
         *               11-->>"I", "J", "K", "L",<br/>
         *               12-->>"M", "N", "O", "P",<br/>
         *               13-->>"Q", "R", "S", "T",<br/>
         *               14-->>"U", "V", "W", "X",<br/>
         */
        public static String uuid(int num16) {
            if (num16 < 0 || num16 > 15) {
                num16 = 0;
            }
            StringBuilder sb = new StringBuilder();
            String pre = Integer.toHexString(num16);
            String uid = pre + UUID.randomUUID().toString().replaceAll("-", "");
            int length = uid.length();
            // 将16进制数转换成64进制数
            // 2的4次方转化成2的6次方的数据
            // bcb da5 f41 172 4bc 28b 920 b1c 5f4 422 6e
            // 3位转2位
            int i = 0;
            for (; i < length; i = i + 3) {
                // 16进制数转化成10进制数
                int end = i + 3;
                if (end >= length) {
                    end = length;
                }
                int t = Integer.parseInt(uid.substring(i, end), 16);
                // 10进制数转化成64进制数
                sb.append(chars[t / 64]);// 第一个数据
                sb.append(chars[t % 64]);// 第二个数据
            }
            // write(sb.toString().substring(0, 1) + "----" + sb.toString());
            write(sb);
            // System.out.println(sb);
            return sb.toString();
        }
    
        public static void write(Object out) {
            if (out == null) {
                return;
            }
            try {
                // 打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件
                FileWriter writer = new FileWriter(fileName, true);
                writer.write(out.toString() + "\n");
                writer.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    运行代码会在D盘中生成out.txt文件,内容如下:
    1XG6g0rfV5uo57vpNEvE4f
    0hQXkufT9aXX00ZF0UcYqp
    1zVt11eDhcaUa2QekcJEWdE
    3C27deVa1h4cbTJPAXXIgBE
    0fF4UvtpB4695fswmw68lg
    2SvWeEOAp9WVcEpXWOuX8B
    0U7eE1kyF7iqI0XP59iqxY
    0hsS1rzP10jVa2RjSzo6g1d
    2tSeCGCvB2ja1mAt0PjYjn
    。。。。。。
    以上内容来自:http://blog.csdn.net/want_water_fish/article/details/67638195


    JAVA生成短8位UUID

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

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


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

    import java.util.HashSet;
    import java.util.Set;
    import java.util.UUID;
    
    public class SerialNo {
    
    	public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
    		"n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7",
    		"8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S",
    		"T", "U", "V", "W", "X", "Y", "Z" };
    
    	public static String generateShortUuid() {
    		StringBuffer shortBuffer = new StringBuffer();
    		String uuid = UUID.randomUUID().toString().replace("-", "");
    		for (int i = 0; i < 8; i++) {
    			String str = uuid.substring(i * 4, i * 4 + 4);
    			int x = Integer.parseInt(str, 16);
    			shortBuffer.append(chars[x % 0x3E]);
    		}
    		return shortBuffer.toString();
    	}
    
    	/**
    	 * @title main
    	 * @date 2015-10-14 下午3:05:17
    	 * @since 2015-10-14
    	 * @version v1.0.0
    	 * @param args
    	 * @throws InterruptedException 
    	 */
    	public static void main(String[] args) throws InterruptedException {
    		final int num = 1000000; // 1,000,000
    		final Set<String> rs_set = new HashSet<String>();
    
    		new Thread(new Runnable() { 
    			@Override
    			public void run() {
    				Set<String> set = new HashSet<String>();
    				for (int i = 0; i < num; i++) {
    					set.add(SerialNo.generateShortUuid());
    				}
    				System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size() 
    						+ " &Repeated Count:" + (num - set.size()));
    				rs_set.addAll(set);
    			}
    		}).start();
    		new Thread(new Runnable() { 
    			@Override
    			public void run() {
    				Set<String> set = new HashSet<String>();
    				for (int i = 0; i < num; i++) {
    					set.add(SerialNo.generateShortUuid());
    				}
    				System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size() 
    						+ " &Repeated Count:" + (num - set.size()));
    				rs_set.addAll(set);
    			}
    		}).start();
    		new Thread(new Runnable() { 
    			@Override
    			public void run() {
    				Set<String> set = new HashSet<String>();
    				for (int i = 0; i < num; i++) {
    					set.add(SerialNo.generateShortUuid());
    				}
    				System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size() 
    						+ " &Repeated Count:" + (num - set.size()));
    				rs_set.addAll(set);
    			}
    		}).start();
    		new Thread(new Runnable() { 
    			@Override
    			public void run() {
    				Set<String> set = new HashSet<String>();
    				for (int i = 0; i < num; i++) {
    					set.add(SerialNo.generateShortUuid());
    				}
    				System.out.println(Thread.currentThread().getName() + "Rs_Count:" + set.size() 
    						+ " &Repeated Count:" + (num - set.size()));
    				rs_set.addAll(set);
    			}
    		}).start();
    
    		Thread.sleep(1000 * 60 * 3);
    		System.out.println("Final Release RS||" + "Rs_Count:" + rs_set.size() 
    				+ " &Repeated Count:" + ((num * 4) - rs_set.size()));
    	}
    }

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

    Thread-1Rs_Count:1000000 &Repeated Count:0
    Thread-2Rs_Count:1000000 &Repeated Count:0
    Thread-0Rs_Count:1000000 &Repeated Count:0
    Thread-3Rs_Count:1000000 &Repeated Count:0
    Final Release RS||Rs_Count:276429 &Repeated Count:3723571

    展开全文
  • 利用java生成uuid

    千次阅读 2020-08-07 20:17:51
    在实际项目中,我们可能想生成一个随机的而且可以保证唯一的标识,比如在给图片命名时,这时就可以采用uuid生成随机字符串,这个随机字符串基本上是不会出现重复的。 什么是UUID uuid,就是 通用唯一识别码 的缩写...
  • java生成UUID的方法总结

    千次阅读 2018-05-18 09:58:27
    转自:https://blog.csdn.net/xinghuo0007/article/details/72868799java生成UUID的方法总结前言:我们开发的时候,数据库表总会有一个主键,以前我们可能会使用自增的数字作为主键。这样做去确实查询的时候比较快,...
  • Java 生成 UUID

    2020-04-30 14:03:25
    1:UUID简介 UUID 是 通用唯一识别码(Universally Unique Identifier)的缩写,是一种软件建构的标准,亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的,是让分布式系统中的所有元素,都能有唯一的...
  • JAVA生成UUID

    2016-09-25 20:52:03
    #JDK 1.5以上 import java.util.UUID; String uuid = UUID.randomUUID().toString();
  • 一、Java 1.UUID 简介 UUID 含义是通用唯一识别码 (Universally Unique Identifier),这是一个软件建构的标准。也是被开源软件基金会 (Open Software Foundation, OSF)的组织应用在分布式计算环境 (Distributed ...
  • JAVA生成UUID并作为数据库表的ID

    千次阅读 2019-06-30 00:13:38
    在接触UUID之前,我建表用的ID一直是用的int型,然后自动增长,这样很方便。 但是这样做却有一些问题,因为数据量大的话,不可能只用一张表,而是几张表,这样会出现id重复,于是有了UUIDUUID 是 通用唯一识别...
  • JAVA生成UUID的方法总结

    千次阅读 2018-06-06 22:43:02
    前言 我们开发的时候,数据库表总会有一个主键,以前我们可能会使用自增的数字作为...于是jdk1.5出了UUID这个类来生成唯一的字符串标识。什么是UUIDUUID有什么用? UUID的组成?UUID的应用?使用UUID的好处在...
  • Java生成UUID使用的第三方包,生成UUID的第三方包,
  • 一、UUID概述 UUID含义是通用唯一识别码 (Universally Unique Identifier),这是一个软件建构的标准,也是被开源软件基金会 (Open Software Foundation, OSF) 的组织在分布式计算环境 (Distributed Computing ...
  • java生成uuid

    2018-03-15 10:21:35
    UUID.randomUUID().toString()生成唯一的UUID。(第一部分与时间有关 由此避开相同的UUID
  • java 生成32位UUID

    2019-03-19 01:53:33
    NULL 博文链接:https://dh189.iteye.com/blog/722580

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,345
精华内容 24,138
关键字:

java生成uuid

java 订阅