Java UUID的生成，不重复

uuid的生成方式有很多，这里是一个尽可能的生成不重复的uuid.

import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.locks.ReentrantLock;

public class UUIDUtils {
    public static void main(String[] args) {
        System.out.println(UUIDUtils.create().toString().replaceAll("-", ""));
        System.out.println(UUIDUtils.random().toString().replaceAll("-", ""));
    }

    private static boolean IS_THREADLOCALRANDOM_AVAILABLE = false;  
    private static Random random;  
    private static final long   leastSigBits;  
    private static final ReentrantLock lock = new ReentrantLock();  
    private static long lastTime;  
  
    static {  
        try {  
            IS_THREADLOCALRANDOM_AVAILABLE = null != UUIDUtils.class.getClassLoader().loadClass(  
                    "java.util.concurrent.ThreadLocalRandom"  
            );  
        } catch(ClassNotFoundException e) {  
        }  
  
        byte[] seed = new SecureRandom().generateSeed(8);  
        leastSigBits = new BigInteger(seed).longValue();  
        if(!IS_THREADLOCALRANDOM_AVAILABLE) {  
            random = new Random(leastSigBits);  
        }  
    }  
  
    private UUIDUtils() {  
    }  
  
    /** 
     * Create a new random UUID. 
     * 
     * @return the new UUID 
     */  
    public static UUID random() {  
        byte[] randomBytes = new byte[16];  
        if(IS_THREADLOCALRANDOM_AVAILABLE) {  
            java.util.concurrent.ThreadLocalRandom.current().nextBytes(randomBytes);  
        } else {  
            random.nextBytes(randomBytes);  
        }  
  
        long mostSigBits = 0;  
        for(int i = 0; i < 8; i++) {  
            mostSigBits = (mostSigBits << 8) | (randomBytes[i] & 0xff);  
        }  
        long leastSigBits = 0;  
        for(int i = 8; i < 16; i++) {  
            leastSigBits = (leastSigBits << 8) | (randomBytes[i] & 0xff);  
        }  
  
        return new UUID(mostSigBits, leastSigBits);  
    }  
  
    /** 
     * Create a new time-based UUID. 
     * 
     * @return the new UUID 
     */  
    public static UUID create() {
        long timeMillis = (System.currentTimeMillis() * 10000) + 0x01B21DD213814000L;
  
        lock.lock();  
        try {  
            if(timeMillis > lastTime) {  
                lastTime = timeMillis;  
            } else {  
                timeMillis = ++lastTime;  
            }  
        } finally {  
            lock.unlock();  
        }  
  
        // time low  
        long mostSigBits = timeMillis << 32;  
  
        // time mid  
        mostSigBits |= (timeMillis & 0xFFFF00000000L) >> 16;  
  
        // time hi and version  
        mostSigBits |= 0x1000 | ((timeMillis >> 48) & 0x0FFF); // version 1  
  
        return new UUID(mostSigBits, leastSigBits);  
    }
}

额外记录一个set转换的工具：

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class SetUtil {

    public static void main(String[] args) {
        String str = "";
        System.out.println(stringToSet(str));
        System.out.println(stringToList(str));
    }
    
    public static Set<String> stringToSet(String str) {
        String[] strs = str.split(",");
        Set<String> set = new HashSet<>();
        Collections.addAll(set, strs);
        return set;
    }

    public static List<String> stringToList(String str) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, str.split(","));
        return list;
    }

    public static String setToString(Set<String> set) {
        return String.join(",", set);
    }

    public static void arrayToSet() {
        Character[] chars = { '1', '2', '3', '4' };
        Set<Character> set = new HashSet<>();
        Collections.addAll(set, chars);
    }

    public static String[] setToArray() {
        Set<Character> set = new HashSet<>();
        String[] strs = set.toArray(new String[set.size()]);
        return strs;
    }
}