java uuid去掉横线_UUID去横杠-的正确方式

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

import java.util.ArrayList;

import java.util.UUID;

public class T {

public static void main(String[] args) {

final int SIZE = 10000;

ArrayList 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的方式,这种方式优化能力最强,而且最优雅

千万不要用正则,正则最难优化,而且效率最低