Java改写UUID,简单使用

简单使用UUID
UUID工具类

import java.io.Serializable;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author xw
 * 参考UUID源码 改写
 */
public final class MyUUID implements Serializable, Comparable<MyUUID> {
    /**
     * SecureRandom 的单例
     */
    private static class Holder {
        static final SecureRandom numberGenerator = getSecureRandom();
    }

    /**
     * 此UUID的最高64有效位
     */
    private final long mostSigBits;

    /**
     * 此UUID的最低64有效位
     */
    private final long leastSigBits;

    /**
     * 私有构造
     *
     * @param data 数据
     */
    private MyUUID(byte[] data) {
        long msb = 0;
        long lsb = 0;
        assert data.length == 16 : "data must be 16 bytes in length";
        for (int i = 0; i < 8; i++) {
            msb = (msb << 8) | (data[i] & 0xff);
        }
        for (int i = 8; i < 16; i++) {
            lsb = (lsb << 8) | (data[i] & 0xff);
        }
        this.mostSigBits = msb;
        this.leastSigBits = lsb;
    }

    /**
     * @return 随机生成的 {@code MyUUID}
     */
    private static MyUUID fastUUID() {
        return randomUUID(false);
    }

    /**
     * @return 随机生成的 {@code MyUUID}
     */
    private static MyUUID randomUUID() {
        return randomUUID(true);
    }

    /**
     * @return 随机生成的 {@code MyUUID}
     */
    private static MyUUID randomUUID(boolean isSecure) {
        final Random ng = isSecure ? Holder.numberGenerator : getRandom();

        byte[] randomBytes = new byte[16];
        ng.nextBytes(randomBytes);
        randomBytes[6] &= 0x0f;
        randomBytes[6] |= 0x40;
        randomBytes[8] &= 0x3f;
        randomBytes[8] |= 0x80;
        return new MyUUID(randomBytes);
    }
    /**
     * @return 此的字符串表现形式
     */
    @Override
    public String toString() {
        return toString(false);
    }

    /**
     * @param isSimple 是否简单模式，简单模式为不带'-'的UUID字符串
     * @return 此的字符串表现形式
     */
    private String toString(boolean isSimple) {
        final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);
     
        builder.append(digits(mostSigBits >> 32, 8));
        if (false == isSimple) {
            builder.append('-');
        }
       
        builder.append(digits(mostSigBits >> 16, 4));
        if (false == isSimple) {
            builder.append('-');
        }
        
        builder.append(digits(mostSigBits, 4));
        if (false == isSimple) {
            builder.append('-');
        }
        
        builder.append(digits(leastSigBits >> 48, 4));
        if (false == isSimple) {
            builder.append('-');
        }
      
        builder.append(digits(leastSigBits, 12));

        return builder.toString();
    }

    /**
     * @return MyUUID 的哈希码值。
     */
    @Override
    public int hashCode() {
        long hilo = mostSigBits ^ leastSigBits;
        return ((int) (hilo >> 32)) ^ (int) hilo;
    }

    /**
     * 将此对象与指定对象比较。
     *
     * @param obj 要与之比较的对象
     * @return 如果对象相同，则返回 {@code true}；否则返回 {@code false}
     */
    @Override
    public boolean equals(Object obj) {
        if ((null == obj) || (obj.getClass() != MyUUID.class)) {
            return false;
        }
        MyUUID id = (MyUUID) obj;
        return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);
    }

    /**
     * @param val 与此 MyUUID 比较的 MyUUID
     * @return 在此 MyUUID 小于、等于或大于 val 时，分别返回 -1、0 或 1。
     */
    @Override
    public int compareTo(MyUUID val) {
        return (this.mostSigBits < val.mostSigBits ? -1 : //
                (this.mostSigBits > val.mostSigBits ? 1 : //
                        (this.leastSigBits < val.leastSigBits ? -1 : //
                                (this.leastSigBits > val.leastSigBits ? 1 : //
                                        0))));
    }

    /**
     * 返回指定数字对应的hex值
     *
     * @param val    值
     * @param digits 位
     * @return 值
     */
    private static String digits(long val, int digits) {
        long hi = 1L << (digits * 4);
        return Long.toHexString(hi | (val & (hi - 1))).substring(1);
    }

    /**
     * 获取{@link SecureRandom}，类提供加密的强随机数生成器 (RNG)
     *
     * @return {@link SecureRandom}
     */
    private static SecureRandom getSecureRandom() {
        try {
            return SecureRandom.getInstance("SHA1PRNG");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        throw new RuntimeException();
    }

    /**
     * 获取随机数生成器对象
     */
    private static ThreadLocalRandom getRandom() {
        return ThreadLocalRandom.current();
    }

    /**
     * 获取随机UUID
     *
     * @return 随机UUID
     */
    public static String getRandomUUID()
    {
        return MyUUID.randomUUID().toString();
    }

    /**
     * 简化的UUID，去掉了横线
     *
     * @return 简化的UUID，去掉了横线
     */
    public static String getSimpleUUID()
    {
        return MyUUID.randomUUID().toString(true);
    }

    /**
     * 获取随机UUID，使用性能更好的ThreadLocalRandom生成UUID
     *
     * @return 随机UUID
     */
    public static String getFastUUID()
    {
        return MyUUID.fastUUID().toString();
    }

    /**
     * 简化的UUID，去掉了横线，使用性能更好的ThreadLocalRandom生成UUID
     *
     * @return 简化的UUID，去掉了横线
     */
    public static String getFastSimpleUUID()
    {
        return MyUUID.fastUUID().toString(true);
    }
}

使用

public class TestUUID {
    public static void main(String[] args) {
        String randomUUID = MyUUID.getRandomUUID();
        String simpleUUID = MyUUID.getSimpleUUID();
        String fastUUID = MyUUID.getFastUUID();
        String fastSimpleUUID = MyUUID.getFastSimpleUUID();
        System.out.println("randomUUID = " + randomUUID);
        System.out.println("simpleUUID = " + simpleUUID);
        System.out.println("fastUUID = " + fastUUID);
        System.out.println("fastSimpleUUID = " + fastSimpleUUID);
    }
}

成果