Me gustaría una utilidad eficiente para generar secuencias únicas de bytes. UUID es un buen candidato pero UUID.randomUUID().toString()genera cosas como44e128a5-ac7a-4c9a-be4c-224b6bf81b20 que es bueno, pero preferiría una cadena sin guiones.

Estoy buscando una forma eficiente de generar cadenas aleatorias, solo a partir de caracteres alfanuméricos (sin guiones u otros símbolos especiales).

Esto lo hace:

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

No es necesario eliminar los guiones de la solicitud HTTP, como puede ver en la URL de este hilo. Pero si desea preparar una URL bien formada sin depender de los datos, debe usar URLEncoder.encode (String data, String encoding) en lugar de cambiar la forma estándar de sus datos. Para la representación de cadena UUID, los guiones son normales.

Terminé escribiendo algo propio basado en la implementación de UUID.java. Tenga en cuenta que no estoy generando un UUID , sino solo una cadena hexadecimal aleatoria de 32 bytes de la manera más eficiente que se me ocurra.

Implementación

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()

Pruebas

Algunas de las entradas que he probado para asegurarme de que funcionan:

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));
}

Usé JUG (Java UUID Generator) para generar una identificación única. Es único en todas las JVM. Bastante bueno de usar. Aquí está el código para su referencia:

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();
}

Puede descargar la biblioteca desde: https://github.com/cowtowncoder/java-uuid-generator

Una solución simple es

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

(Al igual que las soluciones existentes, solo que evita la llamada a String # replaceAll . Aquí no se requiere el reemplazo de la expresión regular, por lo que String # replace siente más natural, aunque técnicamente todavía se implementa con expresiones regulares. Dado que la generación del UUID es más costoso que el reemplazo, no debería haber una diferencia significativa en el tiempo de ejecución).

El uso de la clase UUID es probablemente lo suficientemente rápido para la mayoría de los escenarios, aunque esperaría que alguna variante escrita a mano especializada, que no necesita el procesamiento posterior, sea más rápida. De todos modos, el cuello de botella del cómputo general normalmente será el generador de números aleatorios. En el caso de la clase UUID, utiliza SecureRandom .

Qué generador de números aleatorios utilizar también es una compensación que depende de la aplicación. Si es sensible a la seguridad, SecureRandom es, en general, la recomendación. De lo contrario, ThreadLocalRandom es una alternativa (más rápido que SecureRandom o el antiguo Random , pero no criptográficamente seguro).

Me sorprende ver tantas ideas de reemplazo de cadenas de UUID. Qué tal esto:

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

Esta es la forma más rápida de hacerlo, ya que todo toString () de UUID ya es más costoso, sin mencionar la expresión regular que debe analizarse y ejecutarse o el reemplazo con una cadena vacía.

Acabo de copiar el método UUID toString () y lo actualicé para eliminar "-" de él. Será mucho más rápido y directo que cualquier otra solución

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())

Otra implementación usando reflexión

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));

}

Uso org.apache.commons.codec.binary.Base64 para convertir un UUID en una cadena única segura de URL que tiene 22 caracteres de longitud y tiene la misma unicidad que UUID.

Publiqué mi código en Almacenamiento de UUID como cadena base64