Gerar String Aleatória em Java

1. Gere string aleatória em Java com a expressão regular
2. Gere string alfanumérica aleatória em Java usando o método Math.random()
3. Gerando usando Charset
4. Use Apache Commons Lang

Uma string alfanumérica contém caracteres numéricos e alfabéticos. Em Java, existem vários casos em que cadeias alfanuméricas são utilizadas. Por exemplo, ao gerar uma senha após o usuário se registrar em um aplicativo; na geração de uma entrada de chave primária para identificar um elemento em um banco de dados; na geração de ids de sessão, entre outros.

Este artigo discutirá quatro métodos para gerar uma string alfanumérica aleatória em Java.

1. a expressão regular
2. o método Math.random()
3. o Charset
4. Apache Commons Lang

Gere string aleatória em Java com a expressão regular

Este método é fácil e fornece uma string alfanumérica que contém letras maiúsculas em letras minúsculas e dígitos.

A primeira coisa é pegar caracteres entre 0 e 256.

A segunda etapa é filtrar os caracteres restantes com os elementos que queremos incluir em nossa String aleatória. Lembre-se de que os caracteres com os quais queremos permanecer são 0-9 e A-Z, para que possamos criar um filtro que remova todos os outros caracteres.

A próxima etapa envolve selecionar os caracteres aleatórios e adicioná-los a um StringBuffer. Em seguida, criamos uma String a partir do StringBuffer usando o método toString().

Abaixo está um código de exemplo.

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

Resultado:

A random string : 4H4V7FWP8ZUKEGW

Gere string alfanumérica aleatória em Java usando o método Math.random()

Envolve a criação de uma string que contém todos os caracteres possíveis manualmente. Em seguida, criamos uma string aleatória de comprimento definido, selecionando caracteres e dígitos da string que criamos anteriormente.

Primeiro, definimos as duas variáveis ​​de que precisaremos - o StringBuilder e String. A String conterá todas as letras do alfabeto em maiúsculas e os dígitos 0-9. Esta string não deve ter nenhum símbolo ou espaço porque os índices dos caracteres na string serão usados ​​para selecionar caracteres aleatoriamente.

Em segundo lugar, defina a iteração que é limitada ao comprimento da string aleatória que queremos criar.

Terceiro, gere um índice aleatório usando o método Math.random(). Pegue o caractere da string criada anteriormente que é a posição do índice gerada aleatoriamente e anexe-o ao StringBuilder. Então, podemos obter a string aleatória do StringBuilder usando o método toString().

Abaixo está um código de exemplo.

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

Resultado:

A random string: BCQJPZLG3OC1MQD

Gerando usando Charset

Usamos o Charset, que está no pacote java.nio.charset. Um conjunto de caracteres significa conjunto de caracteres e representa um mapeamento entre caracteres e números. O processo de criação de uma string alfanumérica usando Charset é explicado abaixo.

O primeiro passo é pegar caracteres entre 0 e 256. O método Random() é então aplicado ao array dos caracteres acima. A terceira etapa é verificar se cada caractere é alfabético ou numérico por iteração. Se for qualquer um deles, adicionamos esse caractere ao final da string até chegarmos ao comprimento definido. Os caracteres anexados ao StringBuilder são convertidos na string desejada usando o método toString().

Abaixo está um código de exemplo.

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

Resultado:

A random string: XKT0JAHPRPZ6A3X

Use Apache Commons Lang

Este é o método mais fácil de implementar porque um terceiro trata da implementação, neste caso, o pacote Apache.

O pacote Apache Commons Lang fornece muitos utilitários auxiliares relacionados à manipulação de strings em Java. Por ser um terceiro, ele deve primeiro ser adicionado como uma dependência no projeto.

Podemos utilizar a classe RandomStringUtils para gerar a string aleatória. Esta classe tem três métodos que podem fornecer strings aleatórias:

1. RandomStringUtils.randomNumeric: cria uma string aleatória de comprimento especificado.
2. RandomStringUtils.randomAlphabetic: cria uma string alfabética aleatória com caracteres maiúsculos e minúsculos
3. RandomStringUtils.randomAlphanumeric: cria uma string alfanumérica aleatória com o comprimento especificado.

Abaixo está um exemplo 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(););
  }
}

Resultado:

RM0WMYOKN7AS0KA

O RandomStringUtils.randomAlphanumeric implementa diretamente o alfanumérico aleatório com a opção de ter alfabetos em minúsculas ou maiúsculas ou ambos. Esta é uma maneira eficiente quando você não deseja implementar a geração de string em seu código. A biblioteca Apache é poderosa e possui uma série de outros recursos, como métodos numéricos básicos, simultaneidade e reflexão de objeto.