Outra maneira de jogar a geração do número de série - como jogar base 62?

Normalmente, quando geramos um número de série exclusivo, gostamos de usar a hora como o número de série, mas a duração do número de série do tempo é 15, além de outros como ID do usuário, comerciante etc. O comprimento chega a 50-60 dígitos, o que leva ao nosso número de série. Longa vantagem.

1. Ocupa muito espaço quando armazenado,

2. Eficiência lenta durante a consulta

Podemos encurtar o número da série temporal?

nós sabemos:

De acordo com a tabela de codificação ascII:

Comprimento da codificação do caractere minúsculo a (97) ao usar armazenamento diferente

Binário: 01100001

Octal: 141

Decimal: 97

Hexadecimal: 61

Pode-se ver que com o aumento da base, o comprimento dos caracteres ficará cada vez mais curtos. Se pegarmos os 62 caracteres, normalmente usamos 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ como o código, então a base 62 pode ser expressa.

Antes de codificar, pesquisei git. O código acima foi implementado (base62), não irei implementá-lo novamente, o código é o seguinte:

1.编码，将long型转换为62进制字符串

 /**
 * Encodes a decimal value to a Base62 <code>String</code>.
 *
 * @param b10
 * the decimal value to encode, must be nonnegative.
 * @return the number encoded as a Base62 <code>String</code>.
 */
 public String encodeBase10(long b10) {
 if (b10 < 0) {
 throw new IllegalArgumentException("b10 must be nonnegative");
 }
 String ret = "";
 while (b10 > 0) {
 ret = characters.charAt((int) (b10 % 62)) + ret;
 b10 /= 62;
 }
 return ret;

 }

2. Decodificação, processo reverso

 /**
 * Decodes a Base62 <code>String</code> returning a <code>long</code>.
 *
 * @param b62
 * the Base62 <code>String</code> to decode.
 * @return the decoded number as a <code>long</code>.
 * @throws IllegalArgumentException
 * if the given <code>String</code> contains characters not
 * specified in the constructor.
 */
 public long decodeBase62(String b62) {
 for (char character : b62.toCharArray()) {
 if (!characters.contains(String.valueOf(character))) {
 throw new IllegalArgumentException("Invalid character(s) in string: " + character);
 }
 }
 long ret = 0;
 b62 = new StringBuffer(b62).reverse().toString();
 long count = 1;
 for (char character : b62.toCharArray()) {
 ret += characters.indexOf(character) * count;
 count *= 62;
 }
 return ret;
 }

Caso de teste (pegue o carimbo de data / hora de 15 dígitos como exemplo):

 public static void main(String[] args) {
 Base62 encoder=new Base62();
 Long time=System.nanoTime();
 String timeStr=encoder.encodeBase10(time);
 System.out.println(timeStr);

 System.out.println(time);
 System.out.println(encoder.decodeBase62(timeStr));
 }

A saída do console é a seguinte:

2OdCqJOH8
613534552694770
613534552694770

O comprimento foi alterado de 15 para 9 dígitos, o que reduz o comprimento em 40%, e a eficiência da consulta atual foi melhorada de forma correspondente.

Não é interessante?