Generieren Sie eine zufällige Zeichenkette in Java

  1. Generieren Sie zufällige Zeichenketten in Java mit dem regulären Ausdruck
  2. Generieren Sie zufällige alphanumerische Zeichenketten in Java mit der Methode Math.random()
  3. Generieren mit Charset
  4. Verwenden Sie Apache Commons Lang

Eine alphanumerische Zeichenkette enthält numerische und alphabetische Zeichen. In Java gibt es zahlreiche Fälle, in denen alphanumerische Zeichenketten verwendet werden. Zum Beispiel beim Generieren eines Kennworts, nachdem sich der Benutzer bei einer Anwendung registriert hat; beim Erzeugen eines Primärschlüsseleintrags zum Identifizieren eines Elements in einer Datenbank; unter anderem beim Generieren von Sitzungs-IDs.

In diesem Artikel werden vier Methoden zum Generieren einer zufälligen alphanumerischen Zeichenkette in Java erläutert.

  1. der reguläre Ausdruck
  2. die Methode Math.random()
  3. der Charset
  4. Apache Commons Lang

Generieren Sie zufällige Zeichenketten in Java mit dem regulären Ausdruck

Diese Methode ist einfach und liefert eine alphanumerische Zeichenkette, die Groß- und Kleinbuchstaben enthält.

Das erste ist, Zeichen zwischen 0 und 256 zu nehmen.

Der zweite Schritt besteht darin, die Zeichen zu filtern, die mit den Elementen übrig bleiben sollen, die wir in unseren zufälligen String aufnehmen möchten. Beachten Sie, dass die Zeichen, bei denen wir bleiben möchten, 0-9 und A-Z sind, damit wir einen Filter erstellen können, der alle anderen Zeichen entfernt.

Im nächsten Schritt wählen Sie die zufälligen Zeichen aus und fügen sie einem StringBuffer hinzu. Wir erstellen dann einen String aus dem StringBuffer mit der Methode toString().

Unten finden Sie einen Beispielcode.

import java.nio.charset.*;
import java.util.*;

class GenerateAlphaNumericString {
    static String getRandomString(int i) 
    { 
    
        // bind the length 
        bytearray = new byte[256];         byte[] bytearray;
        String mystring;
        StringBuffer thebuffer;
        String theAlphaNumericS;

        new Random().nextBytes(bytearray); 

        mystring 
            = new String(bytearray, Charset.forName("UTF-8")); 
            
        thebuffer = new StringBuffer();
        
        //remove all spacial char 
        theAlphaNumericS 
            = mystring 
                .replaceAll("[^A-Z0-9]", ""); 

        //random selection
        for (int m = 0; m < theAlphaNumericS.length(); m++) { 

            if (Character.isLetter(theAlphaNumericS.charAt(m)) 
                    && (i > 0) 
                || Character.isDigit(theAlphaNumericS.charAt(m)) 
                    && (i > 0)) { 

                thebuffer.append(theAlphaNumericS.charAt(m)); 
                i--; 
            } 
        } 

        // the resulting string 
        return thebuffer.toString(); 
    } 

    public static void main(String[] args) 
    { 
        // the random string length
        int i = 15; 

        // output 
        System.out.println("A random string: " +  getRandomString(i)); 
    } 
}

Ausgabe:

A random string: 4H4V7FWP8ZUKEGW

Generieren Sie zufällige alphanumerische Zeichenketten in Java mit der Methode Math.random()

Dabei wird eine Zeichenkette erstellt, die alle möglichen Zeichen manuell enthält. Anschließend erstellen wir eine zufällige Zeichenkette mit definierter Länge, indem wir Zeichen und Ziffern aus der zuvor erstellten Zeichenkette auswählen.

Zuerst haben wir die beiden Variablen definiert, die wir benötigen - den StringBuilder und den String. Die Zeichenkette enthält alle Buchstaben des Alphabets in Großbuchstaben und Ziffern 0-9. Diese Zeichenkette sollte kein Symbol oder Leerzeichen enthalten, da die Indizes der Zeichen in der Zeichenkette verwendet werden, um Zeichen zufällig auszuwählen.

Zweitens definieren Sie die Iteration, die auf die Länge der zufälligen Zeichenkette beschränkt ist, die wir erstellen möchten.

Drittens generieren Sie einen Zufallsindex mit der Methode Math.random(). Holen Sie sich das Zeichen aus der zuvor erstellten Zeichenkette, die die zufällig generierte Position des Index darstellt, und hängen Sie es an den StringBuilder an. Dann können wir die zufällige Zeichenkette mit der Methode toString() aus dem StringBuilder abrufen.

Unten finden Sie einen Beispielcode.

class AlphaNumericStringGenerator {
    static String getRandomString(int i) 
    { 
        String theAlphaNumericS;
        StringBuilder builder;
        
        theAlphaNumericS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                    + "0123456789"; 

        //create the StringBuffer
        builder = new StringBuilder(i); 

        for (int m = 0; m < i; m++) { 

            // generate numeric
            int myindex 
                = (int)(theAlphaNumericS.length() 
                        * Math.random()); 

            // add the characters
            builder.append(theAlphaNumericS 
                        .charAt(myindex)); 
        } 

        return builder.toString(); 
    } 

    public static void main(String[] args) 
    { 
        // the random string length
        int i = 15; 

        // output 
        System.out.println("A random string: " +  getRandomString(i)); 
    }
} 

Ausgabe:

A random string: BCQJPZLG3OC1MQD

Generieren mit Charset

Wir verwenden das Charset, der im Paket java.nio.charset enthalten ist. Ein Zeichensatz steht für Zeichensatz und repräsentiert eine Zuordnung zwischen Zeichen und Zahlen. Der Vorgang zum Erstellen einer alphanumerischen Zeichenkette mit Charset wird nachfolgend erläutert.

Der erste Schritt besteht darin, Zeichen zwischen 0 und 256 zu verwenden. Die Methode Random() wird dann auf das Array der obigen Zeichen angewendet. Der dritte Schritt besteht darin, durch Iteration zu überprüfen, ob jedes Zeichen alphabetisch oder numerisch ist. Wenn es einer von beiden ist, fügen wir dieses Zeichen am Ende der Zeichenkette hinzu, bis wir die definierte Länge erreicht haben. Die an den StringBuilder angehängten Zeichen werden mit der Methode toString() in den gewünschten String konvertiert.

Unten finden Sie einen Beispielcode.

import java.nio.charset.*;
import java.util.*; 

class AlphaNumericStringGenerator {
    static String getRandomString(int i) 
    { 

        byte[] bytearray;
        String mystring;
        StringBuffer thebuffer;
        
        bytearray = new byte[256]; 
        new Random().nextBytes(bytearray); 

        mystring 
            = new String(bytearray, Charset.forName("UTF-8")); 

        // Create the StringBuffer
        thebuffer = new StringBuffer(); 

        for (int m = 0; m < mystring.length(); m++) { 

            char n = mystring.charAt(m); 

            if (((n >= 'A' && n <= 'Z') 
                || (n >= '0' && n <= '9')) 
                && (i > 0)) { 

                thebuffer.append(n); 
                i--; 
            } 
        } 

        // resulting string 
        return thebuffer.toString(); 
    } 

    public static void main(String[] args) 
    { 
        // the random string length
        int i = 15; 

        // output 
        System.out.println("A random string: " +  getRandomString(i)); 
    }
}

Ausgabe:

A random string: XKT0JAHPRPZ6A3X

Verwenden Sie Apache Commons Lang

Dies ist die am einfachsten zu implementierende Methode, da ein Dritter die Implementierung übernimmt, in diesem Fall das Paket Apache.

Das Paket Apache Commons Lang bietet viele Hilfsprogramme für die Manipulation von Zeichenketten in Java. Da es sich um einen Drittanbieter handelt, muss er zuerst als Abhängigkeit im Projekt hinzugefügt werden.

Wir können die RandomStringUtils-Klasse verwenden, um die ZufallsZeichenkette zu generieren. Diese Klasse verfügt über drei Methoden, die ZufallsZeichenketten ergeben können:

  1. RandomStringUtils.randomNumeric: Erstellen Sie eine zufällige Zeichenkette mit der angegebenen Länge.
  2. RandomStringUtils.randomAlphabetic: Erstellen Sie eine zufällige alphabetische Zeichenkette mit Groß- und Kleinbuchstaben
  3. RandomStringUtils.randomAlphanumeric: Erstellt eine zufällige alphanumerische Zeichenkette mit der angegebenen Länge.

Unten finden Sie ein Codebeispiel.

import org.apache.commons.lang3.RandomStringUtils;

public class Index {    
    public static void main(String[] args){
        System.out.println(RandomStringUtils.randomAlphanumeric(15)toUpperCase(););
    }
}

Ausgabe:

RM0WMYOKN7AS0KA

Das RandomStringUtils.randomAlphanumeric implementiert das zufällige alphanumerische Zeichen direkt mit der Option, Alphabete in Klein- oder Großbuchstaben oder in beiden zu verwenden. Dies ist eine effiziente Methode, wenn Sie die Zeichenkettengenerierung nicht in Ihrem Code implementieren möchten. Die Apache-Bibliothek ist leistungsstark und verfügt über eine Reihe weiterer Funktionen wie grundlegende numerische Methoden, Parallelität und Objektreflexion.

Verwandter Artikel - Java String

  • Zeichen in Zeichenkette nach Index in Java abrufen
  • Währungsformat in Java