Wie man eine zufällige alphanumerische Zeichenfolge erzeugt

Question

Ich habe nach einem einfach Java-Algorithmus zur Erzeugung einer pseudo-zufälligen alphanumerischen Zeichenkette. In meinem Fall würde sie als eindeutiger Sitzungs-/Schlüsselbezeichner verwendet, der "wahrscheinlich" in folgenden Fällen eindeutig ist 500K+ Generation (meine Bedürfnisse erfordern nicht wirklich etwas viel Anspruchsvolleres).

Im Idealfall könnte ich eine Länge angeben, die meinen Bedürfnissen nach Einzigartigkeit entspricht. Eine generierte Zeichenkette der Länge 12 könnte zum Beispiel wie folgt aussehen "AEYGF7K0DM1X" .

Answer 1

Erstaunlicherweise hat das hier niemand vorgeschlagen, aber:

import java.util.UUID

UUID.randomUUID().toString();

Einfach.

Das hat den Vorteil, dass UUIDs schön lang sind und garantiert kaum kollidieren können.

Wikipedia hat eine gute Erklärung davon:

" ... nur nach der Erzeugung von 1 Milliarde UUIDs pro Sekunde für die nächsten 100 Jahre, würde die Wahrscheinlichkeit, nur ein Duplikat zu erzeugen, etwa 50% betragen."

Die ersten vier Bits sind die Versionsart und zwei für die Variante, so dass man 122 Bits für den Zufall erhält. Wenn Sie also wollen können Sie das Ende abschneiden, um die Größe der UUID zu verringern. Es wird nicht empfohlen, aber Sie haben immer noch eine Menge Zufälligkeit, genug für Ihre 500k Datensätze leicht.

Answer 2

Eine Alternative in Java 8 ist:

static final Random random = new Random(); // Or SecureRandom
static final int startChar = (int) '!';
static final int endChar = (int) '~';

static String randomString(final int maxLength) {
  final int length = random.nextInt(maxLength + 1);
  return random.ints(length, startChar, endChar + 1)
        .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
        .toString();
}

Answer 3

public static String generateSessionKey(int length){
    String alphabet =
        new String("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); // 9

    int n = alphabet.length(); // 10

    String result = new String();
    Random r = new Random(); // 11

    for (int i=0; i<length; i++) // 12
        result = result + alphabet.charAt(r.nextInt(n)); //13

    return result;
}

Answer 4

Die Verwendung von UUIDs ist unsicher, da Teile der UUIDs nicht zufällig sind. Die verfahren von erickson ist sehr ordentlich, aber es erzeugt keine Zeichenketten mit gleicher Länge. Das folgende Snippet sollte ausreichend sein:

/*
 * The random generator used by this class to create random keys.
 * In a holder class to defer initialization until needed.
 */
private static class RandomHolder {
    static final Random random = new SecureRandom();
    public static String randomKey(int length) {
        return String.format("%"+length+"s", new BigInteger(length*5/*base 32,2^5*/, random)
            .toString(32)).replace('\u0020', '0');
    }
}

Warum wählen length*5 ? Nehmen wir den einfachen Fall einer zufälligen Zeichenkette der Länge 1 an, also ein zufälliges Zeichen. Um ein Zufallszeichen zu erhalten, das alle Ziffern 0-9 und die Buchstaben a-z enthält, bräuchten wir eine Zufallszahl zwischen 0 und 35, um von jedem Zeichen eines zu erhalten.

BigInteger bietet einen Konstruktor zur Erzeugung einer Zufallszahl, die gleichmäßig über den Bereich verteilt ist 0 to (2^numBits - 1) . Leider ist 35 keine Zahl, die von 2^numBits - 1 empfangen werden kann.

Wir haben also zwei Möglichkeiten: Entweder wir nehmen 2^5-1=31 o 2^6-1=63 . Wenn wir wählen würden 2^6 würden wir eine Menge "unnötiger" / "längerer" Nummern erhalten. Deshalb 2^5 ist die bessere Option, auch wenn wir vier Zeichen (w-z) verlieren. Um nun eine Zeichenkette einer bestimmten Länge zu erzeugen, können wir einfach eine 2^(length*numBits)-1 Nummer. Das letzte Problem ist, dass, wenn wir eine Zeichenkette mit einer bestimmten Länge haben wollen, der Zufallsgenerator eine kleine Zahl erzeugen könnte, so dass die Länge nicht erreicht wird, so dass wir die Zeichenkette auf die gewünschte Länge auffüllen müssen, indem wir Nullen voranstellen.

Answer 5

import java.util.Random;

public class passGen{
    // Version 1.0
    private static final String dCase = "abcdefghijklmnopqrstuvwxyz";
    private static final String uCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String sChar = "!@#$%^&*";
    private static final String intChar = "0123456789";
    private static Random r = new Random();
    private static StringBuilder pass = new StringBuilder();

    public static void main (String[] args) {
        System.out.println ("Generating pass...");
        while (pass.length () != 16){
            int rPick = r.nextInt(4);
            if (rPick == 0){
                int spot = r.nextInt(26);
                pass.append(dCase.charAt(spot));
            } else if (rPick == 1) {
                int spot = r.nextInt(26);
                pass.append(uCase.charAt(spot));
            } else if (rPick == 2) {
                int spot = r.nextInt(8);
                pass.append(sChar.charAt(spot));
            } else {
                int spot = r.nextInt(10);
                pass.append(intChar.charAt(spot));
            }
        }
        System.out.println ("Generated Pass: " + pass.toString());
    }
}

Dies fügt einfach das Passwort in die Zeichenfolge ein und... ja, es funktioniert gut. Probieren Sie es aus... Es ist sehr einfach; ich habe es geschrieben.