Ich möchte ein effizientes Dienstprogramm, um eindeutige Folgen von Bytes zu generieren. UUID ist ein guter Kandidat, UUID.randomUUID().toString()generiert aber Dinge, 44e128a5-ac7a-4c9a-be4c-224b6bf81b20die gut sind, aber ich würde eine strichlose Zeichenfolge bevorzugen.

Ich suche nach einer effizienten Möglichkeit, zufällige Zeichenfolgen nur aus alphanumerischen Zeichen (keine Bindestriche oder andere spezielle Symbole) zu generieren.

Das macht es:

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

Bindestriche müssen nicht aus der HTTP-Anforderung entfernt werden, wie Sie in der URL dieses Threads sehen können. Wenn Sie jedoch eine wohlgeformte URL ohne Abhängigkeit von Daten erstellen möchten, sollten Sie URLEncoder.encode (String-Daten, String-Codierung) verwenden, anstatt die Standardform Ihrer Daten zu ändern. Für die Darstellung von UUID-Zeichenfolgen sind Striche normal.

Am Ende habe ich etwas Eigenes geschrieben, das auf der Implementierung von UUID.java basiert. Beachten Sie, dass ich keine UUID generiere , sondern nur eine zufällige 32-Byte-Hex-Zeichenfolge auf die effizienteste Art und Weise, die ich mir vorstellen kann.

Implementierung

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

Verwendung

RandomUtil.unique()

Tests

Einige der Eingaben, die ich getestet habe, um sicherzustellen, dass sie funktionieren:

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

Ich habe JUG (Java UUID Generator) verwendet, um eine eindeutige ID zu generieren. Es ist einzigartig für JVMs. Ziemlich gut zu bedienen. Hier ist der Code als Referenz:

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

Sie können die Bibliothek unter folgender Adresse herunterladen: https://github.com/cowtowncoder/java-uuid-generator

Eine einfache Lösung ist

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

(Wie bei den vorhandenen Lösungen wird nur der Aufruf von String # replaceAll vermieden . Das Ersetzen von regulären Ausdrücken ist hier nicht erforderlich, sodass sich das Ersetzen von String # natürlicher anfühlt, obwohl es technisch immer noch mit regulären Ausdrücken implementiert wird. Angesichts der Tatsache, dass die UUID generiert wird teurer als der Austausch, sollte es keinen signifikanten Unterschied in der Laufzeit geben.)

Die Verwendung der UUID-Klasse ist für die meisten Szenarien wahrscheinlich schnell genug, obwohl ich erwarten würde, dass eine spezielle handgeschriebene Variante, für die keine Nachbearbeitung erforderlich ist, schneller ist. Wie auch immer, der Engpass bei der Gesamtberechnung ist normalerweise der Zufallszahlengenerator. Bei der UUID-Klasse wird SecureRandom verwendet .

Welcher Zufallszahlengenerator verwendet werden soll, hängt auch von der Anwendung ab. Wenn es sicherheitsrelevant ist, ist SecureRandom im Allgemeinen die Empfehlung. Andernfalls ist ThreadLocalRandom eine Alternative (schneller als SecureRandom oder das alte Random , jedoch nicht kryptografisch sicher).

Ich bin erstaunt zu sehen, wie viele Zeichenfolgen Ideen von UUID ersetzen. Wie wäre es damit:

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

Dies ist die schnellste Methode, da das gesamte toString () der UUID bereits teurer ist, ganz zu schweigen von dem regulären Ausdruck, der analysiert und ausgeführt werden muss, oder dem Ersetzen durch eine leere Zeichenfolge.

Ich habe gerade die UUID toString () -Methode kopiert und sie aktualisiert, um "-" daraus zu entfernen. Es wird viel schneller und unkomplizierter sein als jede andere Lösung

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

Verwendung:

generateUUIDString(UUID.randomUUID())

Eine weitere Implementierung mit Reflexion

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

}

Ich verwende org.apache.commons.codec.binary.Base64, um eine UUID in eine URL-sichere eindeutige Zeichenfolge zu konvertieren, die 22 Zeichen lang ist und dieselbe Eindeutigkeit wie die UUID aufweist.

Ich habe meinen Code beim Speichern der UUID als base64-Zeichenfolge veröffentlicht