UUID去横杠-的正确方式

原创
2018/07/16 10:39
阅读数 4.9K

UUID如何优雅的去横杠-,用代码和测试说话

import java.util.ArrayList;
import java.util.UUID;

public class T {
    public static void main(String[] args) {
        final int SIZE = 10000;
        ArrayList<UUID> first = new ArrayList<>();
        for (int i = 0; i < SIZE; i++) {
            first.add(UUID.randomUUID());
        }
        long l1 = System.currentTimeMillis();
        first.forEach(key -> directlyToString(key));
        long l2 = System.currentTimeMillis();
        first.forEach(key -> arrayCopyToString(key));
        long l3 = System.currentTimeMillis();
        first.forEach(key -> subStringToString(key));
        long l4 = System.currentTimeMillis();
        first.forEach(key -> forToString(key));
        long l5 = System.currentTimeMillis();
        first.forEach(key -> replaceToString(key));
        long l6 = System.currentTimeMillis();
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid.toString());
        System.out.println(directlyToString(uuid));
        System.out.println(arrayCopyToString(uuid));
        System.out.println(subStringToString(uuid));
        System.out.println(forToString(uuid));
        System.out.println(replaceToString(uuid));
        System.out.println(l2 - l1);
        System.out.println(l3 - l2);
        System.out.println(l4 - l3);
        System.out.println(l5 - l4);
        System.out.println(l6 - l5);
    }

    private static String directlyToString(UUID uuid) {
        return Long.toHexString(uuid.getMostSignificantBits()) + Long.toHexString(uuid.getLeastSignificantBits());
    }

    private static String arrayCopyToString(UUID uuid) {
        char[] dest = new char[32];
        char[] src = uuid.toString().toCharArray();
        System.arraycopy(src, 0, dest, 0, 8);
        System.arraycopy(src, 9, dest, 8, 4);
        System.arraycopy(src, 14, dest, 12, 4);
        System.arraycopy(src, 19, dest, 16, 4);
        System.arraycopy(src, 24, dest, 20, 12);
        return new String(dest);
    }

    private static String subStringToString(UUID uuid) {
        String src = uuid.toString();
        return src.substring(0, 8) + src.substring(9, 13) + src.substring(14, 18) + src.substring(19, 23) + src.substring(24, 36);
    }

    private static String forToString(UUID uuid) {
        char[] src = uuid.toString().toCharArray();
        char[] chars = new char[32];
        for (int i = 0, j = 0; i < src.length; i++) {
            char c = src[i];
            if ('-' != c) {
                chars[j++] = c;
            }
        }
        return new String(chars);
    }

    private static String replaceToString(UUID uuid) {
        return uuid.toString().replaceAll("-", "");
    }
}

总共5种方式,从1000 10000 100000 1000000 10000000分别测试

本机环境,i5 5200u,16G 1600MHZ,win10.0.17134,jdk1.8.0_171

1000次 1千次

38658f6a-8472-40ac-bb83-73baa3bc37f3
38658f6a847240acbb8373baa3bc37f3
38658f6a847240acbb8373baa3bc37f3
38658f6a847240acbb8373baa3bc37f3
38658f6a847240acbb8373baa3bc37f3
38658f6a847240acbb8373baa3bc37f3
139
14
115
6
70

10000次 1万次

226
38
207
16
276

100000次 10万次

191
107
269
90
556

1000000次 100万次

288
232
598
178
1351

10000000 一千万次

1784
1426
2788
2070
10962

100000000 一亿次

24964
19337
37911
22869
146463

结论

arrayCopy的方式效率最高,其次是循环给数组赋值的方式,一直很稳定的高效率,不论次数多少
用longToHexStrin的方式优化能力很强,10万次的时候就会优于字符串拼接
最差劲的方式就是正则,可见正所谓能不用正则就不用正则
推荐使用数组copy或者循环复制的方式
懒省事了,可以用longToHexString的方式,这种方式优化能力最强,而且最优雅
千万不要用正则,正则最难优化,而且效率最低

展开阅读全文
Baa
打赏
1
0 收藏
分享
加载中
刚试过了,谢谢
2018/08/20 11:35
回复
举报
真的吗
2018/08/20 11:04
回复
举报
更多评论
打赏
2 评论
0 收藏
1
分享
返回顶部
顶部