Eu gostaria de um utilitário eficiente para gerar seqüências únicas de bytes. O UUID é um bom candidato, mas UUID.randomUUID().toString()gera coisas como o 44e128a5-ac7a-4c9a-be4c-224b6bf81b20que é bom, mas eu preferiria uma string sem traços.

Eu estou procurando uma maneira eficiente de gerar seqüências aleatórias, apenas a partir de caracteres alfanuméricos (sem traços ou outros símbolos especiais).

Faz isso:

public static void main(String[] args) {
    final String uuid = UUID.randomUUID().toString().replace("-", "");
    System.out.println("uuid = " + uuid);
}

Os traços não precisam ser removidos da solicitação HTTP, como você pode ver no URL deste segmento. Mas se você deseja preparar uma URL bem formada sem depender dos dados, deve usar URLEncoder.encode (dados da string, codificação da string) em vez de alterar a forma padrão dos dados. Para traços de representação de seqüência de caracteres UUID, é normal.

Acabei escrevendo algo próprio com base na implementação do UUID.java. Observe que não estou gerando um UUID , apenas uma sequência hexadecimal aleatória de 32 bytes da maneira mais eficiente possível.

Implementação

import java.security.SecureRandom;
import java.util.UUID;

public class RandomUtil {
    // Maxim: Copied from UUID implementation :)
    private static volatile SecureRandom numberGenerator = null;
    private static final long MSB = 0x8000000000000000L;

    public static String unique() {
        SecureRandom ng = numberGenerator;
        if (ng == null) {
            numberGenerator = ng = new SecureRandom();
        }

        return Long.toHexString(MSB | ng.nextLong()) + Long.toHexString(MSB | ng.nextLong());
    }       
}

Uso

RandomUtil.unique()

Testes

Algumas das entradas que testei para garantir que estão funcionando:

public static void main(String[] args) {
    System.out.println(UUID.randomUUID().toString());
    System.out.println(RandomUtil.unique());

    System.out.println();
    System.out.println(Long.toHexString(0x8000000000000000L |21));
    System.out.println(Long.toBinaryString(0x8000000000000000L |21));
    System.out.println(Long.toHexString(Long.MAX_VALUE + 1));
}

Eu usei o JUG (Java UUID Generator) para gerar um ID exclusivo. É único nas JVMs. Muito bom de usar. Aqui está o código para sua referência:

private static final SecureRandom secureRandom = new SecureRandom();
private static final UUIDGenerator generator = UUIDGenerator.getInstance();

public synchronized static String generateUniqueId() {
  UUID uuid = generator.generateRandomBasedUUID(secureRandom);

  return uuid.toString().replaceAll("-", "").toUpperCase();
}

É possível baixar a biblioteca em: https://github.com/cowtowncoder/java-uuid-generator

Uma solução simples é

UUID.randomUUID().toString().replace("-", "")

(Como as soluções existentes, apenas que evita a chamada String # replaceAll . A substituição da expressão regular não é necessária aqui, portanto, a String # replace parece mais natural, embora tecnicamente ainda seja implementada com expressões regulares. Dado que a geração do UUID é mais caro que a substituição, não deve haver uma diferença significativa no tempo de execução.)

O uso da classe UUID provavelmente é rápido o suficiente para a maioria dos cenários, embora eu esperasse que alguma variante escrita à mão especializada, que não precisa do pós-processamento, fosse mais rápida. De qualquer forma, o gargalo do cálculo geral será normalmente o gerador de números aleatórios. No caso da classe UUID, ele usa SecureRandom .

Qual gerador de números aleatórios a ser usado também é uma troca que depende do aplicativo. Se for sensível à segurança, o SecureRandom é, em geral, a recomendação. Caso contrário, o ThreadLocalRandom é uma alternativa (mais rápido que o SecureRandom ou o antigo Random , mas não criptograficamente seguro).

Estou surpreso ao ver tantas seqüências de caracteres substituindo idéias de UUID. Que tal agora:

UUID temp = UUID.randomUUID();
String uuidString = Long.toHexString(temp.getMostSignificantBits())
     + Long.toHexString(temp.getLeastSignificantBits());

Essa é a maneira mais rápida de fazer isso, pois todo o toString () do UUID já é mais caro, sem mencionar a expressão regular que deve ser analisada e executada ou a substituição por uma string vazia.

Acabei de copiar o método UUID toString () e atualizei-o para remover "-". Será muito mais rápido e direto do que qualquer outra solução

public String generateUUIDString(UUID uuid) {
    return (digits(uuid.getMostSignificantBits() >> 32, 8) +
            digits(uuid.getMostSignificantBits() >> 16, 4) +
            digits(uuid.getMostSignificantBits(), 4) +
            digits(uuid.getLeastSignificantBits() >> 48, 4) +
            digits(uuid.getLeastSignificantBits(), 12));
}

/** Returns val represented by the specified number of hex digits. */
private String digits(long val, int digits) {
    long hi = 1L << (digits * 4);
    return Long.toHexString(hi | (val & (hi - 1))).substring(1);
}

Uso:

generateUUIDString(UUID.randomUUID())

Outra implementação usando reflexão

public String generateString(UUID uuid) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

    if (uuid == null) {
        return "";
    }

    Method digits = UUID.class.getDeclaredMethod("digits", long.class, int.class);
    digits.setAccessible(true);

    return ( (String) digits.invoke(uuid, uuid.getMostSignificantBits() >> 32, 8) +
            digits.invoke(uuid, uuid.getMostSignificantBits() >> 16, 4) +
            digits.invoke(uuid, uuid.getMostSignificantBits(), 4) +
            digits.invoke(uuid, uuid.getLeastSignificantBits() >> 48, 4) +
            digits.invoke(uuid, uuid.getLeastSignificantBits(), 12));

}

Eu uso org.apache.commons.codec.binary.Base64 para converter um UUID em uma string exclusiva segura para URLs com 22 caracteres e com a mesma exclusividade que o UUID.

Publiquei meu código em Armazenando UUID como base64 String