19位UUID

向右看齐 2021-11-11 06:40 269阅读 0赞

### 22位算法：[https://blog.csdn.net/qq\_35425070/article/details/100548181][https_blog.csdn.net_qq_35425070_article_details_100548181] ###

# 19位UUID代码： #

package com.lym.order.util;
    
    import java.util.Base64;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.UUID;
    
    /** * 19 位UUID 生成器 * 性能：i7-8750h 100w次生成耗时： * 原生36位（0.9s） * 去掉'-'32位（1s） * Base64压缩22位（2.7s） * 字母大小写19位（4.7s） * / public class Numbers { final static char[] digits = { '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', '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', '+', '-' }; private final static Map<Character, Integer> digitMap = new HashMap<>(); static { for (int i = 0; i < digits.length; i++) { digitMap.put(digits[i], i); } } /** * 支持的最大进制数 */  
        private static final int MAX_RADIX = digits.length;
      
        /** * 支持的最小进制数 */  
        private static final int MIN_RADIX = 2;
      
        /** * 将第一个参数 long 换为 radix 进制（最大支持62进制，62 = 数字 + 大小写字母） * @param longNum 长整型 * @param radix 转化后的进制 * @return longNum 的 radix 进制 */  
        public static String changeRadix(long longNum, int radix) { 
            if (radix < MIN_RADIX || radix > MAX_RADIX)  
                radix = 10;  
            if (radix == 10)  
                return Long.toString(longNum);
      
            final int size = 65;  
            int charPos = 64;  
      
            char[] buf = new char[size];  
            boolean negative = (longNum < 0);
      
            if (!negative) {   
                longNum = -longNum;
            }  
      
            while (longNum <= -radix) { 
                buf[charPos--] = digits[(int) (-(longNum % radix))];
                longNum = longNum / radix;
            }  
            buf[charPos] = digits[(int) (-longNum)];
      
            if (negative) {   
                buf[--charPos] = '-';  
            }  
      
            return new String(buf, charPos, (size - charPos));  
        }
    
        /** * 抛出专有异常 * @param exceptionDescription 异常说明 * @return NumberFormatException 封装好说明的异常 */
        private static NumberFormatException newNumberFormatException(String exceptionDescription) { 
            return new NumberFormatException("For input string: \"" + exceptionDescription + "\"");
        }
    
        /** * 将 radix 进制的字符串 numberParam 转换为 long * 复制的 JDK Long 源码， 改为最大支持 62 进制{@link java.lang.Long#parseLong(String s, int radix)} * @param numberParam 数字字符串 * @param radix 字符串的进制，最大支持 62 进制 * @return 转换后的 long */  
        public static long toLong(String numberParam, int radix) { 
            if (numberParam== null) { 
                throw new NumberFormatException("null");  
            }  
            if (radix < MIN_RADIX) { 
                throw new NumberFormatException("radix " + radix  
                        + " less than Numbers.MIN_RADIX: " + Numbers.MIN_RADIX);
            }  
            if (radix > MAX_RADIX) {   
                throw new NumberFormatException("radix " + radix  
                        + " greater than Numbers.MAX_RADIX: " + Numbers.MAX_RADIX);
            }  
      
            long result = 0;  
            boolean negative = false;  
            int i = 0, len = numberParam.length();
            long limit = -Long.MAX_VALUE;  
            long multmin;  
            Integer digit;  
      
            if (len > 0) {   
                char firstChar = numberParam.charAt(0);
                if (firstChar < '0') {   
                    if (firstChar == '-') {   
                        negative = true;  
                        limit = Long.MIN_VALUE;  
                    } else if (firstChar != '+')  
                        throw newNumberFormatException(numberParam);
      
                    if (len == 1) {   
                        throw newNumberFormatException(numberParam);
                    }  
                    i++;  
                }  
                multmin = limit / radix;  
                while (i < len) {   
                    digit = digitMap.get(numberParam.charAt(i++));
                    if (digit == null) {   
                        throw newNumberFormatException(numberParam);
                    }  
                    if (digit < 0) {   
                        throw newNumberFormatException(numberParam);
                    }  
                    if (result < multmin) {   
                        throw newNumberFormatException(numberParam);
                    }  
                    result *= radix;  
                    if (result < limit + digit) {   
                        throw newNumberFormatException(numberParam);
                    }  
                    result -= digit;  
                }  
            } else {   
                throw newNumberFormatException(numberParam);
            }  
            return negative ? result : -result;  
        }
    
        /** * 转换进制，并返回 String 类型 * @param longNum 待转换的 long * @param digits 需要参与运算的保留位数，除后 digits 位，其余数字不参与运算 * @return longNum 的后 digits 运算后的结果 */
        private static String digits(long longNum, int digits) { 
            long hi = 1L << digits;
            // hi + longNum % hi。 longNum % hi ：去除digits过滤的数。 + hi，补偿位运算中过滤的第 digits 位。
            return Numbers.changeRadix(hi | (longNum & (hi - 1)), Numbers.MAX_RADIX)
                    .substring(1);  
        }  
        /** * 以62进制（字母加数字）生成19位UUID，最短的UUID * @return 压缩版（19位） string 类型的UUID， */  
        public static String random19UUID() { 
            UUID uuid = UUID.randomUUID();  
            StringBuilder sb = new StringBuilder();
            // 前 64 位最高 32 位
            sb.append(digits(uuid.getMostSignificantBits() >> 32, 32));
            // 前 64 位次高 16 位
            sb.append(digits(uuid.getMostSignificantBits() >> 16, 16));
            // 前 64 位最低 16 位
            sb.append(digits( uuid.getMostSignificantBits(), 16));
    
            // 后 64 位最高 16 位
            sb.append(digits(uuid.getLeastSignificantBits() >> 48, 16));
            // 后 64 位最低 48 位
            sb.append(digits( uuid.getLeastSignificantBits(), 48));
            return sb.toString();  
        }
    
        public static String random19UUID(UUID uuid) { 
            StringBuilder sb = new StringBuilder();
            sb.append(digits(uuid.getMostSignificantBits() >> 32, 8));
            sb.append(digits(uuid.getMostSignificantBits() >> 16, 4));
            sb.append(digits( uuid.getMostSignificantBits(), 4));
            sb.append(digits(uuid.getLeastSignificantBits() >> 48, 4));
            sb.append(digits( uuid.getLeastSignificantBits(), 12));
            return sb.toString();
        }
    
        public static String uuid(){ 
            UUID uuid = UUID.randomUUID();
            long msb = uuid.getMostSignificantBits();
            long lsb = uuid.getLeastSignificantBits();
    
            byte[] b = new byte[16];
            for (int i = 0; i < 8; i++) { 
                b[i] = (byte) (msb >>> (8 * (7 - i)) & 0xff);
                b[i + 8] = (byte) (lsb >>> (8 * (7 - i)) & 0xff);
            }
            return "";
        }
    
        public static void main(String[] args){ 
            UUID uuid = UUID.fromString("cfa762a8-725c-482f-8f4a-d334a0f1273b");
            long high = uuid.getMostSignificantBits();
            long low = uuid.getLeastSignificantBits();
            System.out.println("uuid: " + uuid);
            System.out.println("high: " + high);
            System.out.println("low: " + low);
            System.out.println("press: " + Numbers.changeRadix(high, 62) + Numbers.changeRadix(low, 62));
            System.out.println(Numbers.random19UUID(uuid));
    
    
        }
    }

[https_blog.csdn.net_qq_35425070_article_details_100548181]: https://blog.csdn.net/qq_35425070/article/details/100548181