Java - Genera stringa casuale

In questo tutorial, mostreremo come generare una stringa casuale in Java, prima utilizzando le librerie Java standard, quindi utilizzando una variante di Java 8 e infine utilizzando la libreria Apache Commons Lang.

Questo articolo fa parte della serie "Java - Back to Basic" qui su Baeldung.

1. Genera una stringa illimitata casuale con Java normale

Iniziamo in modo semplice e generiamo una stringa casuale limitata a 7 caratteri:

@Test public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() { byte[] array = new byte[7]; // length is bounded by 7 new Random().nextBytes(array); String generatedString = new String(array, Charset.forName("UTF-8")); System.out.println(generatedString); }

Tieni presente che la nuova stringa non sarà nulla alfanumerico remotamente.

2. Genera stringa delimitata casuale con Java normale

Successivamente, diamo un'occhiata alla creazione di una stringa casuale più vincolata; genereremo una stringa casuale utilizzando lettere alfabetiche minuscole e una lunghezza impostata:

@Test public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() { int leftLimit = 97; // letter 'a' int rightLimit = 122; // letter 'z' int targetStringLength = 10; Random random = new Random(); StringBuilder buffer = new StringBuilder(targetStringLength); for (int i = 0; i < targetStringLength; i++) { int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1)); buffer.append((char) randomLimitedInt); } String generatedString = buffer.toString(); System.out.println(generatedString); }

3. Genera stringa alfabetica casuale con Java 8

Ora, usiamo Random.ints - aggiunto in JDK 8 - per generare una stringa alfabetica :

@Test public void givenUsingJava8_whenGeneratingRandomAlphabeticString_thenCorrect() { int leftLimit = 97; // letter 'a' int rightLimit = 122; // letter 'z' int targetStringLength = 10; Random random = new Random(); String generatedString = random.ints(leftLimit, rightLimit + 1) .limit(targetStringLength) .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append) .toString(); System.out.println(generatedString); }

4. Genera stringa alfanumerica casuale con Java 8

E poi possiamo ampliare il nostro set di caratteri per ottenere una stringa alfanumerica :

@Test public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() 

Si noti l'uso del metodo di filtro sopra per escludere i caratteri Unicode compresi tra 65 e 90, per evitare caratteri fuori intervallo.

5. Genera stringa casuale delimitata con Apache Commons Lang

La libreria Commons Lang di Apache aiuta molto con la generazione di stringhe casuali. Diamo un'occhiata alla generazione di una stringa limitata utilizzando solo lettere :

@Test public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() { int length = 10; boolean useLetters = true; boolean useNumbers = false; String generatedString = RandomStringUtils.random(length, useLetters, useNumbers); System.out.println(generatedString); }

Quindi, invece di tutto il codice di basso livello nell'esempio Java, questo è fatto con un semplice one-liner.

6. Genera stringa alfabetica con Apache Commons Lang

Un altro esempio molto semplice: questa volta una stringa limitata con solo caratteri alfabetici, ma senza passare flag booleani nell'API:

@Test public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() { String generatedString = RandomStringUtils.randomAlphabetic(10); System.out.println(generatedString); }

7. Genera stringa alfanumerica con Apache Commons Lang

E infine - la stessa stringa delimitata casuale ma questa volta - numerica:

@Test public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() { String generatedString = RandomStringUtils.randomAlphanumeric(10); System.out.println(generatedString); }

E il gioco è fatto: creare stringhe limitate e illimitate con Java semplice, una variante di Java 8 o la libreria Apache Commons.

8. Conclusione

Attraverso diversi metodi di implementazione siamo stati in grado di generare stringhe associate e non associate, utilizzando Java semplice, una variante di Java 8 o la Apache Commons Library.

In questi esempi Java, abbiamo usato java.util.Random , ma un punto degno di nota è che non è crittograficamente sicuro. Prendi in considerazione l'utilizzo di java.security.SecureRandom invece per le applicazioni sensibili alla sicurezza.

L'implementazione di tutti questi esempi e frammenti può essere trovata nel progetto GitHub. Questo è un progetto basato su Maven, quindi dovrebbe essere facile da importare ed eseguire.