Java - Generar cadena aleatoria

En este tutorial, vamos a mostrar cómo generar una cadena aleatoria en Java, primero usando las bibliotecas estándar de Java, luego usando una variante de Java 8 y finalmente usando la biblioteca Apache Commons Lang.

Este artículo es parte de la serie "Java - Back to Basic" aquí en Baeldung.

1. Genere una cadena ilimitada aleatoria con Java simple

Comencemos de manera simple y generemos una cadena aleatoria limitada a 7 caracteres:

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

Tenga en cuenta que la nueva cadena no será ni remotamente alfanumérica.

2. Genere una cadena acotada aleatoriamente con Java simple

A continuación, veamos cómo crear una cadena aleatoria más restringida; vamos a generar una cadena aleatoria usando letras alfabéticas minúsculas y una longitud establecida:

@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. Genere una cadena alfabética aleatoria con Java 8

Ahora, usemos Random.ints , agregado en JDK 8, para generar una cadena alfabética :

@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. Genere una cadena alfanumérica aleatoria con Java 8

Y luego podemos ampliar nuestro conjunto de caracteres para obtener una Cadena alfanumérica :

@Test public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() 

Observe el uso del método de filtro anterior para omitir los caracteres Unicode entre 65 y 90, para evitar caracteres fuera de rango.

5. Genere una cadena aleatoria acotada con Apache Commons Lang

La biblioteca Commons Lang de Apache ayuda mucho con la generación de cadenas aleatorias. Echemos un vistazo a la generación de una cadena acotada usando solo letras :

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

Entonces, en lugar de todo el código de bajo nivel en el ejemplo de Java, este se hace con una simple línea.

6. Genere una cadena alfabética con Apache Commons Lang

Otro ejemplo muy simple, esta vez una cadena limitada con solo caracteres alfabéticos, pero sin pasar indicadores booleanos a la API:

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

7. Genere una cadena alfanumérica con Apache Commons Lang

Y finalmente, la misma cadena acotada aleatoriamente pero esta vez, numérica:

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

Y ahí lo tenemos: creando cadenas delimitadas y no delimitadas con Java simple, una variante de Java 8 o Apache Commons Library.

8. Conclusión

A través de diferentes métodos de implementación, pudimos generar cadenas vinculadas y no vinculadas, utilizando Java simple, una variante de Java 8 o la biblioteca Apache Commons.

En estos ejemplos de Java, hemos utilizado java.util.Random , pero un punto que vale la pena mencionar es que no es criptográficamente seguro. Considere usar java.security.SecureRandom en su lugar para aplicaciones sensibles a la seguridad.

La implementación de todos estos ejemplos y fragmentos se puede encontrar en el proyecto GitHub. Este es un proyecto basado en Maven, por lo que debería ser fácil de importar y ejecutar.