Generar cadena aleatoria en Java

1. Genere una cadena aleatoria en Java con la expresión regular
2. Genere una cadena alfanumérica aleatoria en Java utilizando el método Math.random()
3. Generación mediante juego de caracteres
4. Utilice Apache Commons Lang

Una cadena alfanumérica contiene caracteres numéricos y alfabéticos. En Java, existen numerosos casos en los que se utilizan cadenas alfanuméricas. Por ejemplo, al generar una contraseña después de que el usuario se registre en una aplicación; al generar una entrada de clave primaria para identificar un elemento en una base de datos; en la generación de identificadores de sesión, entre otros.

Este artículo discutirá cuatro métodos para generar una cadena alfanumérica aleatoria en Java.

1. la expresión regular
2. el método Math.random()
3. El método Charset
4. Apache Commons Lang

Genere una cadena aleatoria en Java con la expresión regular

Este método es fácil y proporciona una cadena alfanumérica que contiene mayúsculas en minúsculas y dígitos.

Lo primero es tomar caracteres que estén entre 0 y 256.

El segundo paso es filtrar los caracteres que quedarán con los elementos que queremos incluir en nuestra cadena aleatoria. Tenga en cuenta que los caracteres con los que queremos permanecer son 0-9 y A-Z, por lo que podemos crear un filtro que elimine todos los demás caracteres.

El siguiente paso consiste en seleccionar los caracteres aleatorios y agregarlos a un StringBuffer. Luego creamos un String a partir del StringBuffer usando el método toString().

A continuación se muestra un código de muestra.

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

Producción :

A random string: 4H4V7FWP8ZUKEGW

Genere una cadena alfanumérica aleatoria en Java utilizando el método Math.random()

Implica crear una cadena que contiene todos los caracteres posibles manualmente. Luego creamos una Cadena aleatoria de longitud definida seleccionando caracteres y dígitos de la cadena que creamos previamente.

Primero, definimos las dos variables que necesitaremos: StringBuilder y String. La Cadena contendrá todas las letras del alfabeto en mayúsculas y dígitos del 0 al 9. Esta cadena no debe tener símbolo ni espacio porque los índices de los caracteres de la cadena se utilizarán para seleccionar caracteres al azar.

En segundo lugar, defina la iteración que está limitada a la longitud de la cadena aleatoria que queremos crear.

En tercer lugar, genere un índice aleatorio utilizando el método Math.random(). Obtenga el carácter de la cadena creada anteriormente que es la posición del índice generada aleatoriamente y añádalo al StringBuilder. Entonces podemos obtener la cadena aleatoria del StringBuilder usando el método toString().

A continuación se muestra un código de muestra.

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

Producción :

A random string: BCQJPZLG3OC1MQD

Generación mediante juego de caracteres

Usamos Charset, que está en el paquete java.nio.charset. Un juego de caracteres significa juego de caracteres y representa un mapeo entre caracteres y números. El proceso de creación de una cadena alfanumérica usando Charset se explica a continuación.

El primer paso es tomar caracteres entre 0 y 256. A continuación, se aplica el método Random() a el array de caracteres de arriba. El tercer paso es verificar si cada carácter es alfabético o numérico por iteración. Si es alguno de ellos, agregamos ese carácter al final de la cadena hasta llegar a la longitud definida. Los caracteres añadidos al StringBuilder se convierten en la cadena deseada utilizando el método toString().

A continuación se muestra un código de muestra.

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

Producción :

A random string: XKT0JAHPRPZ6A3X

Utilice Apache Commons Lang

Este es el método más fácil de implementar porque un tercero maneja la implementación, en este caso, el paquete Apache.

El paquete Apache Commons Lang proporciona muchas utilidades de ayuda relacionadas con la manipulación de cadenas en Java. Debido a que es un tercero, primero debe agregarse como una dependencia en el proyecto.

Podemos utilizar la clase RandomStringUtils para generar la cadena aleatoria. Esta clase tiene tres métodos que pueden dar cadenas aleatorias:

1. RandomStringUtils.randomNumeric: crea una cadena aleatoria de longitud especificada.
2. RandomStringUtils.randomAlphabetic: crea una cadena alfabética aleatoria con mayúsculas y minúsculas
3. RandomStringUtils.randomAlphanumeric: crea una cadena alfanumérica aleatoria con la longitud especificada.

A continuación se muestra un ejemplo de código.

import org.apache.commons.lang3.RandomStringUtils;

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

Producción :

RM0WMYOKN7AS0KA

El RandomStringUtils.randomAlphanumeric implementa directamente el alfanumérico aleatorio con la opción de tener alfabetos en minúsculas, mayúsculas o ambos. Esta es una forma eficiente cuando no desea implementar la generación de cadenas dentro de su código. La biblioteca Apache es poderosa y tiene una serie de otras características, como métodos numéricos básicos, simultaneidad y reflexión de objetos.