Java - Générer une chaîne aléatoire

Dans ce tutoriel, nous allons montrer comment générer une chaîne aléatoire en Java - d'abord en utilisant les bibliothèques Java standard, puis en utilisant une variante Java 8, et enfin en utilisant la bibliothèque Apache Commons Lang.

Cet article fait partie de la série «Java - Back to Basic» ici sur Baeldung.

1. Générer une chaîne aléatoire non bornée avec Java brut

Commençons simplement et générons une chaîne aléatoire limitée à 7 caractères:

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

Gardez à l'esprit que la nouvelle chaîne ne sera rien de alphanumérique à distance.

2. Générer une chaîne délimitée aléatoire avec Java brut

Ensuite - regardons la création d'une chaîne aléatoire plus contrainte; nous allons générer une chaîne aléatoire en utilisant des lettres alphabétiques minuscules et une longueur définie:

@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. Générer une chaîne alphabétique aléatoire avec Java 8

Maintenant, utilisons Random.ints - ajouté dans JDK 8 - pour générer une chaîne alphabétique :

@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. Générer une chaîne alphanumérique aléatoire avec Java 8

Et puis nous pouvons élargir notre jeu de caractères afin d'obtenir une chaîne alphanumérique :

@Test public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() 

Notez l'utilisation de la méthode de filtrage ci-dessus pour omettre les caractères Unicode entre 65 et 90 - pour éviter les caractères hors plage.

5. Générer une chaîne aléatoire délimitée avec Apache Commons Lang

La bibliothèque Commons Lang d'Apache aide beaucoup à la génération de chaînes aléatoires. Jetons un coup d'œil à la génération d'une chaîne limitée en utilisant uniquement des lettres :

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

Donc - au lieu de tout le code de bas niveau dans l'exemple Java - celui-ci est fait avec une simple ligne unique.

6. Générer une chaîne alphabétique avec Apache Commons Lang

Un autre exemple très simple - cette fois une chaîne bornée avec uniquement des caractères alphabétiques, mais sans passer d'indicateurs booléens dans l'API:

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

7. Générer une chaîne alphanumérique avec Apache Commons Lang

Et enfin - la même chaîne aléatoire bornée mais cette fois - numérique:

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

Et là, nous l'avons - créer des chaînes limitées et illimitées avec Java brut, une variante Java 8 ou la bibliothèque Apache Commons.

8. Conclusion

Grâce à différentes méthodes d'implémentation, nous avons pu générer des chaînes liées et non liées, en utilisant Java brut, une variante Java 8 ou la bibliothèque Apache Commons.

Dans ces exemples Java, nous avons utilisé java.util.Random , mais il convient de mentionner qu'il n'est pas cryptographiquement sécurisé. Pensez à utiliser java.security.SecureRandom à la place pour les applications sensibles à la sécurité.

L'implémentation de tous ces exemples et extraits de code se trouve dans le projet GitHub. Il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter.