Genera stringa casuale in Java

  1. Genera stringa casuale in Java con l’espressione regolare
  2. Genera una stringa alfanumerica casuale in Java usando il metodo Math.random()
  3. Generare usando Charset
  4. Usa Apache Commons Lang

Una stringa alfanumerica contiene caratteri numerici e alfabetici. In Java, ci sono numerosi casi in cui vengono utilizzate stringhe alfanumeriche. Ad esempio, nella generazione di una password dopo che l’utente si è registrato su un’applicazione; nel generare una voce di chiave primaria per identificare un elemento in un database; nella generazione di ID di sessione, tra gli altri.

Questo articolo discuterà quattro metodi per generare una stringa alfanumerica casuale in Java.

  1. l’espressione regolare
  2. il metodo Math.random()
  3. il set di caratteri
  4. Apache Commons Lang

Genera stringa casuale in Java con l’espressione regolare

Questo metodo è semplice e fornisce una stringa alfanumerica che contiene caratteri maiuscoli in caratteri minuscoli e cifre.

La prima cosa è prendere caratteri compresi tra 0 e 256.

Il secondo passo è filtrare i caratteri da lasciare con gli elementi che vogliamo includere nella nostra stringa casuale. Tieni presente che i caratteri con cui vogliamo rimanere sono 0-9 e A-Z, quindi possiamo creare un filtro che rimuove tutti gli altri caratteri.

Il passo successivo consiste nel selezionare i caratteri casuali e aggiungerli a un StringBuffer. Quindi creiamo una stringa dallo StringBuffer utilizzando il metodo toString().

Di seguito è riportato un codice di esempio.

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

Produzione:

A random string: 4H4V7FWP8ZUKEGW

Genera una stringa alfanumerica casuale in Java usando il metodo Math.random()

Implica la creazione manuale di una stringa che contiene tutti i caratteri possibili. Creiamo quindi una stringa casuale di lunghezza definita selezionando caratteri e cifre dalla stringa che abbiamo creato in precedenza.

Per prima cosa, abbiamo definito le due variabili di cui avremo bisogno: StringBuilder e String. La Stringa conterrà tutte le lettere dell’alfabeto in maiuscolo e le cifre 0-9. Questa stringa non deve contenere simboli o spazi perché gli indici dei caratteri nella stringa verranno utilizzati per selezionare i caratteri in modo casuale.

In secondo luogo, definisci l’iterazione che è limitata alla lunghezza della stringa casuale che vogliamo creare.

Terzo, genera un indice casuale usando il metodo Math.random(). Prendi il carattere dalla stringa creata in precedenza che è la posizione dell’indice generato casualmente e aggiungilo a StringBuilder. Quindi possiamo ottenere la stringa casuale da StringBuilder usando il metodo toString().

Di seguito è riportato un codice di esempio.

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

Produzione:

A random string: BCQJPZLG3OC1MQD

Generare usando Charset

Usiamo il Charset, che si trova nel pacchetto java.nio.charset. Un set di caratteri sta per set di caratteri e rappresenta una mappatura tra caratteri e numeri. Il processo di creazione di una stringa alfanumerica utilizzando Charset è spiegato di seguito.

Il primo passo è prendere caratteri compresi tra 0 e 256. Il metodo Random() viene quindi applicato all’array dei caratteri sopra. Il terzo passaggio consiste nel verificare se ogni carattere è alfabetico o numerico per iterazione. Se è uno di loro, aggiungiamo quel carattere alla fine della stringa finché non arriviamo alla lunghezza definita. I caratteri aggiunti a StringBuilder vengono convertiti nella stringa desiderata utilizzando il metodo toString().

Di seguito è riportato un codice di esempio.

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

Produzione:

A random string: XKT0JAHPRPZ6A3X

Usa Apache Commons Lang

Questo è il metodo più semplice da implementare perché una terza parte gestisce l’implementazione, in questo caso, il pacchetto Apache.

Il pacchetto Apache Commons Lang fornisce molte utilità di supporto relative alla manipolazione delle stringhe in Java. Poiché si tratta di una terza parte, deve prima essere aggiunta come dipendenza nel progetto.

Possiamo usare la classe RandomStringUtils per generare la stringa casuale Questa classe ha tre metodi che possono fornire stringhe casuali:

  1. RandomStringUtils.randomNumeric: crea una stringa casuale di lunghezza specificata.
  2. RandomStringUtils.randomAlphabetic: crea una stringa alfabetica casuale con caratteri maiuscoli e minuscoli
  3. RandomStringUtils.randomAlphanumeric: crea una stringa alfanumerica casuale con la lunghezza specificata.

Di seguito è riportato un esempio di codice.

import org.apache.commons.lang3.RandomStringUtils;

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

Produzione:

RM0WMYOKN7AS0KA

Il RandomStringUtils.randomAlphanumeric implementa direttamente l’alfanumerico casuale con l’opzione di avere alfabeti in minuscolo o maiuscolo o entrambi. Questo è un modo efficiente quando non vuoi implementare la generazione di stringhe all’interno del tuo codice. La libreria Apache è potente e ha una serie di altre funzionalità come metodi numerici di base, concorrenza e riflessione degli oggetti.

Articolo correlato - Java String

  • Enum a String in Java
  • Ottieni l'ultimo carattere di una stringa in Java