随机ID号码

--生成随机ID号

package com.g_j_x.myjava;

/**
 * 单例模式, 格式化调用
 * @author g_j_x
 * @date 2017-4-27
 */
public class Global
{
    private static Global instance;
    private Global(){}
    public static Global getInstance()
    {
        if (instance == null) {
            instance = new Global();
        }
        return instance;
    }
    
    public String UUID()
    {
        return UUID.randomUUID().toString().replace("-","");
    }
}

package com.g_j_x.myjava;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

/**
 * 生成随机ID
 * @author g_j_x
 * @date 2017-4-27
 */
public final class UUID
  implements Serializable, Comparable<UUID>
{
  private static final long serialVersionUID = -4856846361193249489L;
  private final long mostSigBits;
  private final long leastSigBits;
  private transient int version = -1;
  private transient int variant = -1;
  private volatile transient long timestamp = -1L;
  private transient int sequence = -1;
  private transient long node = -1L;
  private transient int hashCode = -1;
  
  private UUID(byte[] paramArrayOfByte)
  {
    long l1 = 0L;
    long l2 = 0L;
    /**
     * 在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；
     * 如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告并且退出。一般来说，assertion用于保证程序最基本、关键的正确性。
     * assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。
     * 在语法上，为了支持assertion，Java增加了一个关键字assert。它包括两种表达式，分别如下：
     * 1. assert expression1;
     * 2. assert expression1: expression2;
     * expression1表示一个boolean表达式，expression2表示一个基本类型、表达式或者是一个Object，用于在失败时输出错误信息。
     * 1.      参数 -esa 和 -dsa：
     * 它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中，也使了assertion语句，因此如果用户需要观察它们的运行情况，
     * 就需要打开系统类的assertion功能 ，我们可使用-esa参数打开，使用 -dsa参数关闭。
     * -esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions，全名和缩写名有同样的功能。
     */
    assert (paramArrayOfByte.length == 16);
    for (int i = 0; i < 8; i++) {
      l1 = l1 << 8 | paramArrayOfByte[i] & 0xFF;
    }
    for (int i = 8; i < 16; i++) {
      l2 = l2 << 8 | paramArrayOfByte[i] & 0xFF;
    }
    this.mostSigBits = l1;
    this.leastSigBits = l2;
  }
  
  public UUID(long paramLong1, long paramLong2)
  {
    this.mostSigBits = paramLong1;
    this.leastSigBits = paramLong2;
  }
  
  public static UUID randomUUID()
  {
    SecureRandom localSecureRandom = Holder.numberGenerator;
    byte[] arrayOfByte = new byte[16];
    localSecureRandom.nextBytes(arrayOfByte);
    byte[] tmp17_14 = arrayOfByte;
    tmp17_14[6] = ((byte)(tmp17_14[6] & 0xF));
    byte[] tmp27_24 = arrayOfByte;
    tmp27_24[6] = ((byte)(tmp27_24[6] | 0x40));
    byte[] tmp37_34 = arrayOfByte;
    tmp37_34[8] = ((byte)(tmp37_34[8] & 0x3F));
    byte[] tmp47_44 = arrayOfByte;
    tmp47_44[8] = ((byte)(tmp47_44[8] | 0x80));
    return new UUID(arrayOfByte);
  }
  
  public static UUID nameUUIDFromBytes(byte[] paramArrayOfByte)
  {
    MessageDigest localMessageDigest;
    try
    {
      localMessageDigest = MessageDigest.getInstance("MD5");
    }
    catch (NoSuchAlgorithmException localNoSuchAlgorithmException)
    {
      throw new InternalError("MD5 not supported");
    }
    byte[] arrayOfByte = localMessageDigest.digest(paramArrayOfByte);
    byte[] tmp29_26 = arrayOfByte;
    tmp29_26[6] = ((byte)(tmp29_26[6] & 0xF));
    byte[] tmp39_36 = arrayOfByte;
    tmp39_36[6] = ((byte)(tmp39_36[6] | 0x30));
    byte[] tmp49_46 = arrayOfByte;
    tmp49_46[8] = ((byte)(tmp49_46[8] & 0x3F));
    byte[] tmp59_56 = arrayOfByte;
    tmp59_56[8] = ((byte)(tmp59_56[8] | 0x80));
    return new UUID(arrayOfByte);
  }
  
  public static UUID fromString(String paramString)
  {
    String[] arrayOfString = paramString.split("-");
    if (arrayOfString.length != 5) {
      throw new IllegalArgumentException("Invalid UUID string: " + paramString);
    }
    for (int i = 0; i < 5; i++) {
      arrayOfString[i] = ("0x" + arrayOfString[i]);
    }
    long l1 = Long.decode(arrayOfString[0]).longValue();
    l1 <<= 16;
    l1 |= Long.decode(arrayOfString[1]).longValue();
    l1 <<= 16;
    l1 |= Long.decode(arrayOfString[2]).longValue();
    long l2 = Long.decode(arrayOfString[3]).longValue();
    l2 <<= 48;
    l2 |= Long.decode(arrayOfString[4]).longValue();
    return new UUID(l1, l2);
  }
  
  public long getLeastSignificantBits()
  {
    return this.leastSigBits;
  }
  
  public long getMostSignificantBits()
  {
    return this.mostSigBits;
  }
  
  public int version()
  {
    if (this.version < 0) {
      this.version = ((int)(this.mostSigBits >> 12 & 0xF));
    }
    return this.version;
  }
  
  public int variant()
  {
    if (this.variant < 0) {
      if (this.leastSigBits >>> 63 == 0L) {
        this.variant = 0;
      } else if (this.leastSigBits >>> 62 == 2L) {
        this.variant = 2;
      } else {
        this.variant = ((int)(this.leastSigBits >>> 61));
      }
    }
    return this.variant;
  }
  
  public long timestamp()
  {
    if (version() != 1) {
      throw new UnsupportedOperationException("Not a time-based UUID");
    }
    long l = this.timestamp;
    if (l < 0L)
    {
      l = (this.mostSigBits & 0xFFF) << 48;
      l |= (this.mostSigBits >> 16 & 0xFFFF) << 32;
      l |= this.mostSigBits >>> 32;
      this.timestamp = l;
    }
    return l;
  }
  
  public int clockSequence()
  {
    if (version() != 1) {
      throw new UnsupportedOperationException("Not a time-based UUID");
    }
    if (this.sequence < 0) {
      this.sequence = ((int)((this.leastSigBits & Integer.parseInt(String.valueOf("0x3FFF000000000000"))) >>> 48));
    }
    return this.sequence;
  }
  
  public long node()
  {
    if (version() != 1) {
      throw new UnsupportedOperationException("Not a time-based UUID");
    }
    if (this.node < 0L) {
      this.node = (this.leastSigBits & Integer.parseInt(String.valueOf("0xFFFFFFFFFFFF")));
    }
    return this.node;
  }
  
  public String toString()
  {
    return digits(this.mostSigBits >> 32, 8) + "-" + digits(this.mostSigBits >> 16, 4) + "-" + digits(this.mostSigBits, 4) + "-" + digits(this.leastSigBits >> 48, 4) + "-" + digits(this.leastSigBits, 12);
  }
  
  private static String digits(long paramLong, int paramInt)
  {
    long l = 1L << paramInt * 4;
    return Long.toHexString(l | paramLong & l - 1L).substring(1);
  }
  
  public int hashCode()
  {
    if (this.hashCode == -1) {
      this.hashCode = ((int)(this.mostSigBits >> 32 ^ this.mostSigBits ^ this.leastSigBits >> 32 ^ this.leastSigBits));
    }
    return this.hashCode;
  }
  
  public boolean equals(Object paramObject)
  {
    if (!(paramObject instanceof UUID)) {
      return false;
    }
    if (((UUID)paramObject).variant() != variant()) {
      return false;
    }
    UUID localUUID = (UUID)paramObject;
    return (this.mostSigBits == localUUID.mostSigBits) && (this.leastSigBits == localUUID.leastSigBits);
  }
  
  public int compareTo(UUID paramUUID)
  {
    return this.leastSigBits > paramUUID.leastSigBits ? 1 : this.leastSigBits < paramUUID.leastSigBits ? -1 : this.mostSigBits > paramUUID.mostSigBits ? 1 : this.mostSigBits < paramUUID.mostSigBits ? -1 : 0;
  }
  
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    this.version = -1;
    this.variant = -1;
    this.timestamp = -1L;
    this.sequence = -1;
    this.node = -1L;
    this.hashCode = -1;
  }
  
  private static class Holder
  {
    static final SecureRandom numberGenerator = new SecureRandom();
    
    private Holder() {}
  }
}