Como gerar aleatoriamente um alfa-numérico string?

StackOverflow https://stackoverflow.com/questions/41107

Pergunta

Eu estive procurando por um simples Java algoritmo para gerar uma pseudo-aleatórios seqüência de caracteres alfanuméricos.Na minha situação, seria usado como uma única sessão/identificador de chave de que "provavelmente" ser exclusivo sobre 500K+ geração (minhas necessidades não precisar de qualquer coisa muito mais sofisticada).

Idealmente, eu gostaria de ser capaz de especificar um comprimento dependendo de minha singularidade necessidades.Por exemplo, um gerado de seqüência de caracteres de comprimento 12 pode ser algo como "AEYGF7K0DM1X".

Foi útil?

Solução

Algoritmo

Para gerar uma seqüência aleatória, concatenar caracteres sorteados aleatoriamente a partir do conjunto de todos os símbolos até a cadeia de atingir o comprimento desejado.

Implementação

Eis alguns bastante simples e bastante flexível código para a geração aleatória de identificadores. Leia as informações que se segue para notas importantes do aplicativo.

import java.security.SecureRandom;
import java.util.Locale;
import java.util.Objects;
import java.util.Random;

public class RandomString {

    /**
     * Generate a random string.
     */
    public String nextString() {
        for (int idx = 0; idx < buf.length; ++idx)
            buf[idx] = symbols[random.nextInt(symbols.length)];
        return new String(buf);
    }

    public static final String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    public static final String lower = upper.toLowerCase(Locale.ROOT);

    public static final String digits = "0123456789";

    public static final String alphanum = upper + lower + digits;

    private final Random random;

    private final char[] symbols;

    private final char[] buf;

    public RandomString(int length, Random random, String symbols) {
        if (length < 1) throw new IllegalArgumentException();
        if (symbols.length() < 2) throw new IllegalArgumentException();
        this.random = Objects.requireNonNull(random);
        this.symbols = symbols.toCharArray();
        this.buf = new char[length];
    }

    /**
     * Create an alphanumeric string generator.
     */
    public RandomString(int length, Random random) {
        this(length, random, alphanum);
    }

    /**
     * Create an alphanumeric strings from a secure generator.
     */
    public RandomString(int length) {
        this(length, new SecureRandom());
    }

    /**
     * Create session identifiers.
     */
    public RandomString() {
        this(21);
    }

}

Exemplos de utilização

Criar um gerador de insegurança para 8 caracteres identificadores:

RandomString gen = new RandomString(8, ThreadLocalRandom.current());

Criar um seguro gerador de identificadores de sessão:

RandomString session = new RandomString();

Criar um gerador de fácil leitura de códigos para impressão.As seqüências de caracteres são mais do que completa de seqüências de caracteres alfanuméricos para compensar o uso de menos símbolos:

String easy = RandomString.digits + "ACEFGHJKLMNPQRUVWXYabcdefhijkprstuvwx";
RandomString tickets = new RandomString(23, new SecureRandom(), easy);

Utilizar como identificadores de sessão

A geração de identificadores de sessão que são susceptíveis de ser único não é bom o suficiente, ou você poderia simplesmente usar um contador simples.Atacantes seqüestrar sessões quando previsíveis identificadores são usados.

Há uma tensão entre o comprimento e a segurança.Menor identificadores são mais fáceis de adivinhar, porque existem menos possibilidades.Mas mais identificadores de consumir mais largura de banda e armazenamento.Um maior conjunto de símbolos de ajuda, mas pode causar problemas de codificação de se identificadores são incluídos em URLs ou re-introduzido pela mão.

A fonte subjacente da aleatoriedade, ou entropia, para os identificadores de sessão devem vir a partir de um gerador de números aleatórios projetado para criptografia.No entanto, inicializar estes geradores podem, por vezes, ser computacionalmente caro ou lenta, por isso os esforços devem ser feitos para utilizá-los quando possível.

Utilizar como identificadores de objecto

Nem todos os aplicativos necessitam de segurança.A atribuição aleatória pode ser uma maneira eficiente de várias entidades para gerar identificadores em um espaço compartilhado, sem qualquer coordenação ou de particionamento.A coordenação pode ser lenta, especialmente em um cluster ou em ambiente distribuído, e dividir um espaço causa problemas quando as entidades acabar com ações que são demasiado pequenas ou demasiado grandes.

Identificadores gerados sem tomar medidas para torná-los imprevisíveis devem ser protegidas por outros meios, se um invasor pode ser capaz de ver e manipulá-los, como acontece na maioria das aplicações web.Deve haver uma autorização separada do sistema que protege os objectos cujo identificador pode ser adivinhada por um intruso sem permissão de acesso.

Cuidados também devem ser tomados para usar identificadores que são longos o suficiente para fazer colisões improvável, dada a total previsto do número de identificadores.Isso é conhecido como "o aniversário do paradoxo." A probabilidade de uma colisão, p, é aproximadamente n2/(2tx), onde n é o número de identificadores, na verdade, gerado, q é o número de diferentes símbolos no alfabeto, e x é o comprimento dos identificadores.Este deve ser um número muito pequeno, como 2‑50 ou menos.

Trabalhar isso mostra que a chance de colisão entre 500k de 15 caracteres identificadores é de cerca de 2‑52, que provavelmente é menos provável do que não detectados erros de raios cósmicos, etc.

Comparação com os UUIDs

De acordo com a sua especificação, UUIDs não são projetados para ser imprevisível, e não deve ser usadas como identificadores de sessão.

UUIDs em seu formato padrão de levar um monte de espaço:36 caracteres, por apenas 122 bits de entropia.(Nem todos os bits de um "random" UUID são selecionados aleatoriamente.) Um escolhido aleatoriamente de caracteres alfanuméricos mais pacotes de entropia em apenas 21 caracteres.

UUIDs não são flexíveis;eles têm uma estrutura padrão e o layout.Esta é sua principal virtude, bem como a sua principal fraqueza.Ao colaborar com uma parte externa, a padronização oferecida pelo Uuid pode ser útil.Para utilização puramente interna, que pode ser ineficiente.

Outras dicas

Java fornece uma maneira de fazer isso diretamente.Se você não deseja que os traços, eles são fáceis de retirar.Basta usar uuid.replace("-", "")

import java.util.UUID;

public class randomStringGenerator {
    public static void main(String[] args) {
        System.out.println(generateString());
    }

    public static String generateString() {
        String uuid = UUID.randomUUID().toString();
        return "uuid = " + uuid;
    }
}

Saída:

uuid = 2d7428a6-b58c-4008-8575-f05549f16316

static final String AB = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static SecureRandom rnd = new SecureRandom();

String randomString( int len ){
   StringBuilder sb = new StringBuilder( len );
   for( int i = 0; i < len; i++ ) 
      sb.append( AB.charAt( rnd.nextInt(AB.length()) ) );
   return sb.toString();
}

Se você está feliz em usar o Apache classes, você pode usar org.apache.commons.text.RandomStringGenerator (commons-texto).

Exemplo:

RandomStringGenerator randomStringGenerator =
        new RandomStringGenerator.Builder()
                .withinRange('0', 'z')
                .filteredBy(CharacterPredicates.LETTERS, CharacterPredicates.DIGITS)
                .build();
randomStringGenerator.generate(12); // toUpperCase() if you want

Desde commons-lang 3.6, RandomStringUtils é preterido.

Em uma linha:

Long.toHexString(Double.doubleToLongBits(Math.random()));

http://mynotes.wordpress.com/2009/07/23/java-generating-random-string/

Você pode usar o Apache biblioteca para este: RandomStringUtils

RandomStringUtils.randomAlphanumeric(20).toUpperCase();

Isso é facilmente alcançável sem quaisquer bibliotecas externas.

1.Criptografia Pseudo-Aleatório De Geração De Dados

Primeiro você precisa de um PRNG criptográfico.Java tem SecureRandom por que, normalmente, utiliza as melhores entropia da fonte na máquina (por exemplo, /dev/random) . Leia mais aqui.

SecureRandom rnd = new SecureRandom();
byte[] token = new byte[byteLength];
rnd.nextBytes(token);

Nota: SecureRandom é o mais lento, mas mais seguro maneira em Java de geração de bytes aleatórios.Eu, no entanto, NÃO recomendamos considerando o desempenho aqui, pois normalmente não tem um impacto real sobre a sua aplicação, a menos que você tem para gerar milhões de senhas por segundo.

2.Espaço necessário de Valores Possíveis

Em seguida, você tem que decidir "como único" seu token precisa ser.Todo e só ponto de considerar a entropia é certificar-se de que o sistema pode resistir a ataques de força bruta:o espaço de possíveis valores deve ser tão grande que qualquer invasor pode tentar somente uma insignificante a proporção de valores no não-tempo ridícula1.Identificadores únicos, tais como aleatória UUID tem 122bit de entropia (ie.2^122 = 5.3x10^36) - a chance de colisão é "*(...) para que haja uma uma em um bilhão, a chance de duplicação, 103 trilhões versão 4 UUIDs deve ser gerado2". Vamos escolher 128 bits, pois se encaixa exatamente em 16 bytes e é visto como altamente suficiente para ser exclusivo para basicamente todos, mas o mais extremo, casos de uso e você não tem que pensar sobre duplicatas.Aqui está uma simples tabela de comparação de entropia, incluindo análise simples dos aniversário problema.

comparison of token sizes

Para simples requisitos de 8 ou 12 bytes de comprimento pode ser suficiente, mas com 16 bytes que estão no "lado seguro".

E é basicamente isso.A última coisa é pensar sobre codificação, então ele pode ser representado como uma impressão de texto (leia-se, um String).

3.Binário para Texto de Codificação

Típico codificações incluem:

  • Base64 cada personagem que codifica 6bit a criação de um 33% de sobrecarga.Felizmente, existem implementações padrão em Java 8+ e Android.Com os mais velhos Java você pode usar qualquer um dos inúmeras bibliotecas de terceiros.Se você deseja que sua tokens url uso seguro da url-seguro versão do RFC4648 (que geralmente é suportado pela maioria das implementações).Exemplo de codificação de 16 bytes com preenchimento: XfJhfv3C0P6ag7y9VQxSbw==

  • Base32 cada personagem que codifica 5bit a criação de 40% de sobrecarga.Isto irá usar A-Z e 2-7 tornando-se razoavelmente eficiente em termos de espaço, enquanto ser sensível a maiúsculas e minúsculas alfa-numérico.Não há implementação padrão do JDK.Exemplo de codificação de 16 bytes sem preenchimento: WUPIL5DQTZGMF4D3NX5L7LNFOY

  • Base16 (hex) cada personagem que codifica 4bit que exigem de 2 caracteres por byte (ie.De 16 bytes criar uma seqüência de caracteres de comprimento 32).Portanto, hex é menos eficiente em termos de espaço de Base32 mas é seguro usar na maioria dos casos (url), pois utiliza apenas 0-9 e A para F.Exemplo de codificação de 16 bytes: 4fa3dd0f57cb3bf331441ed285b27735. Veja uma discussão sobre a conversão para hexadecimal aqui.

Adicionais codificações como Base85 e o exótico Base122 existem com o melhor/pior eficiência de espaço.Você pode criar sua própria codificação (que, basicamente, a maioria das respostas neste segmento de fazer) mas eu aconselho contra ele, se você não tem requisitos muito específicos.Ver mais esquemas de codificação no artigo da Wikipédia.

4.Resumo e Exemplo

  • Utilização SecureRandom
  • Use pelo menos 16 bytes (2^128) de valores possíveis
  • Codificar de acordo com os seus requisitos (normalmente hex ou base32 se você precisar de alfa-numérico)

Não

  • ...use o home brew codificação: melhor manutenção e legível para os outros, se eles vêem que o padrão de codificação que você utilize em vez de estranho para loops de criação de chars ao mesmo tempo.
  • ...usar UUID: ele não tem garantias sobre a aleatoriedade;você está desperdiçando 6bits de entropia e ter detalhado representação de seqüência de caracteres

Exemplo:Hex Token Gerador De

public static String generateRandomHexToken(int byteLength) {
    SecureRandom secureRandom = new SecureRandom();
    byte[] token = new byte[byteLength];
    secureRandom.nextBytes(token);
    return new BigInteger(1, token).toString(16); //hex encoding
}

//generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd

Exemplo:Base64 Token Gerador De Url (Seguro)

public static String generateRandomBase64Token(int byteLength) {
    SecureRandom secureRandom = new SecureRandom();
    byte[] token = new byte[byteLength];
    secureRandom.nextBytes(token);
    return Base64.getUrlEncoder().withoutPadding().encodeToString(token); //base64 encoding
}

//generateRandomBase64Token(16) -> EEcCCAYuUcQk7IuzdaPzrg

Exemplo:Java Ferramenta CLI

Se você quer um pronto-para-usar cli ferramenta que você pode usar dados: https://github.com/patrickfav/dice

usando Dólar deve ser simples, como:

// "0123456789" + "ABCDE...Z"
String validCharacters = $('0', '9').join() + $('A', 'Z').join();

String randomString(int length) {
    return $(validCharacters).shuffle().slice(length).toString();
}

@Test
public void buildFiveRandomStrings() {
    for (int i : $(5)) {
        System.out.println(randomString(12));
    }
}

ele produz algo como isso:

DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7

Aqui está ele, em Java:

import static java.lang.Math.round;
import static java.lang.Math.random;
import static java.lang.Math.pow;
import static java.lang.Math.abs;
import static java.lang.Math.min;
import static org.apache.commons.lang.StringUtils.leftPad

public class RandomAlphaNum {
  public static String gen(int length) {
    StringBuffer sb = new StringBuffer();
    for (int i = length; i > 0; i -= 12) {
      int n = min(12, abs(i));
      sb.append(leftPad(Long.toString(round(random() * pow(36, n)), 36), n, '0'));
    }
    return sb.toString();
  }
}

Aqui está um exemplo de execução:

scala> RandomAlphaNum.gen(42)
res3: java.lang.String = uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy

Surpreendente, ninguém aqui tem sugerido isso, mas: 

import java.util.UUID

UUID.randomUUID().toString();

É fácil.

O benefício disso é UUIDs são bons e longos e garantido para ser quase impossível para colidir.

A wikipédia tem uma boa explicação para isso:

"...apenas depois de gerar 1 bilhão de UUIDs a cada segundo para os próximos 100 anos, a probabilidade de criação de apenas um duplicado seria de cerca de 50%."

http://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates

Os primeiros 4 bits são o tipo de versão e 2 para a variante de modo a obter 122 bits aleatórios.Então, se você quer você pode truncar a partir do fim de reduzir o tamanho de um UUID.Não é recomendado, mas você ainda tem um monte de aleatoriedade, o suficiente para o seu e 500 mil registros fácil.

Um curto e de fácil solução, mas usa apenas letras minúsculas e números:

Random r = new java.util.Random ();
String s = Long.toString (r.nextLong () & Long.MAX_VALUE, 36);

O tamanho é de cerca de 12 dígitos para 36 base e não pode ser melhorada ainda mais, de que maneira.É claro que você pode acrescentar várias instâncias.

Uma alternativa em Java 8 é:

static final Random random = new Random(); // Or SecureRandom
static final int startChar = (int) '!';
static final int endChar = (int) '~';

static String randomString(final int maxLength) {
  final int length = random.nextInt(maxLength + 1);
  return random.ints(length, startChar, endChar + 1)
        .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
        .toString();
}

public static String generateSessionKey(int length){
String alphabet = 
        new String("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); //9
int n = alphabet.length(); //10

String result = new String(); 
Random r = new Random(); //11

for (int i=0; i<length; i++) //12
    result = result + alphabet.charAt(r.nextInt(n)); //13

return result;
}

Usando Uuid é inseguro, porque partes de um UUID arn não aleatório em tudo.O procedimento de @erickson é muito legal, mas não cria cordas de mesmo comprimento.O trecho a seguir devem ser suficientes:

/*
 * The random generator used by this class to create random keys.
 * In a holder class to defer initialization until needed.
 */
private static class RandomHolder {
    static final Random random = new SecureRandom();
    public static String randomKey(int length) {
        return String.format("%"+length+"s", new BigInteger(length*5/*base 32,2^5*/, random)
            .toString(32)).replace('\u0020', '0');
    }
}

Por que escolher length*5.Vamos supor o caso simples de uma seqüência aleatória de comprimento, 1, portanto, um carácter aleatório.Para obter um caractere aleatório que contém todos os dígitos 0-9 e os caracteres a-z, precisaríamos de um número aleatório entre 0 e 35 para obter um de cada personagem. BigInteger fornece um construtor para gerar um número aleatório uniformemente distribuída sobre o intervalo 0 to (2^numBits - 1).Infelizmente 35 nenhum número que pode ser recebido por 2^numBits - 1.Então, temos duas opções:Quer ir com 2^5-1=31 ou 2^6-1=63.Se quisermos escolher 2^6 gostaríamos de ter um monte de "unnecesarry" / "mais" números.Portanto, 2^5 é a melhor opção, mesmo se perdemos de 4 caracteres (w-z).Agora gerar uma seqüência de caracteres de um determinado período, podemos simplesmente usar uma 2^(length*numBits)-1 o número.O último problema, se queremos uma seqüência de caracteres com um determinado comprimento, aleatório, o que poderia gerar um pequeno número, de modo que o comprimento não for atendida, então temos que preencher a seqüência de caracteres ao comprimento necessário colocar zeros.

import java.util.Random;

public class passGen{
    //Verison 1.0
    private static final String dCase = "abcdefghijklmnopqrstuvwxyz";
    private static final String uCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String sChar = "!@#$%^&*";
    private static final String intChar = "0123456789";
    private static Random r = new Random();
    private static String pass = "";

    public static void main (String[] args) {
        System.out.println ("Generating pass...");
        while (pass.length () != 16){
            int rPick = r.nextInt(4);
            if (rPick == 0){
                int spot = r.nextInt(25);
                pass += dCase.charAt(spot);
            } else if (rPick == 1) {
                int spot = r.nextInt (25);
                pass += uCase.charAt(spot);
            } else if (rPick == 2) {
                int spot = r.nextInt (7);
                pass += sChar.charAt(spot);
            } else if (rPick == 3){
                int spot = r.nextInt (9);
                pass += intChar.charAt (spot);
            }
        }
        System.out.println ("Generated Pass: " + pass);
    }
}

Então, o que isto faz é apenas adicionar a palavra-passe para a cadeia e ...sim funciona bem, confira...muito simples.Eu escrevi isso

Eu encontrei esta solução que gera aleatoriamente um hex string codificada.Fornecido teste de unidade parece que segure a minha principal caso de uso.Embora, é um pouco mais complexo do que algumas das outras respostas.

/**
 * Generate a random hex encoded string token of the specified length
 *  
 * @param length
 * @return random hex string
 */
public static synchronized String generateUniqueToken(Integer length){ 
    byte random[] = new byte[length];
    Random randomGenerator = new Random();
    StringBuffer buffer = new StringBuffer();

    randomGenerator.nextBytes(random);

    for (int j = 0; j < random.length; j++) {
        byte b1 = (byte) ((random[j] & 0xf0) >> 4);
        byte b2 = (byte) (random[j] & 0x0f);
        if (b1 < 10)
            buffer.append((char) ('0' + b1));
        else
            buffer.append((char) ('A' + (b1 - 10)));
        if (b2 < 10)
            buffer.append((char) ('0' + b2));
        else
            buffer.append((char) ('A' + (b2 - 10)));
    }
    return (buffer.toString());
}

@Test
public void testGenerateUniqueToken(){
    Set set = new HashSet();
    String token = null;
    int size = 16;

    /* Seems like we should be able to generate 500K tokens 
     * without a duplicate 
     */
    for (int i=0; i<500000; i++){
        token = Utility.generateUniqueToken(size);

        if (token.length() != size * 2){
            fail("Incorrect length");
        } else if (set.contains(token)) {
            fail("Duplicate token generated");
        } else{
            set.add(token);
        }
    }
}

import java.util.Date;
import java.util.Random;

public class RandomGenerator {

  private static Random random = new Random((new Date()).getTime());

    public static String generateRandomString(int length) {
      char[] values = {'a','b','c','d','e','f','g','h','i','j',
               'k','l','m','n','o','p','q','r','s','t',
               'u','v','w','x','y','z','0','1','2','3',
               '4','5','6','7','8','9'};

      String out = "";

      for (int i=0;i<length;i++) {
          int idx=random.nextInt(values.length);
          out += values[idx];
      }
      return out;
    }
}

import java.util.*;
import javax.swing.*;
public class alphanumeric{
    public static void main(String args[]){
        String nval,lenval;
        int n,len;

        nval=JOptionPane.showInputDialog("Enter number of codes you require : ");
        n=Integer.parseInt(nval);

        lenval=JOptionPane.showInputDialog("Enter code length you require : ");
        len=Integer.parseInt(lenval);

        find(n,len);

    }
    public static void find(int n,int length) {
        String str1="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        StringBuilder sb=new StringBuilder(length);
        Random r = new Random();

        System.out.println("\n\t Unique codes are \n\n");
        for(int i=0;i<n;i++){
            for(int j=0;j<length;j++){
                sb.append(str1.charAt(r.nextInt(str1.length())));
            }
            System.out.println("  "+sb.toString());
            sb.delete(0,length);
        }
    }
}

  1. Altere a Seqüência de caracteres, conforme suas necessidades.

  2. String é imutável.Aqui StringBuilder.append é mais eficiente do que a concatenação de seqüência de caracteres.


public static String getRandomString(int length) {
       final String characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+";
       StringBuilder result = new StringBuilder();
       while(length > 0) {
           Random rand = new Random();
           result.append(characters.charAt(rand.nextInt(characters.length())));
           length--;
       }
       return result.toString();
    }

Não gosta de nenhuma dessas respostas sobre o "simples" solução :S

Gostaria de ir para uma simples ;), java puro, um forro (entropia é baseado em uma seqüência aleatória de comprimento e dado conjunto de caracteres):

public String randomString(int length, String characterSet) {
    return IntStream.range(0, length).map(i -> new SecureRandom().nextInt(characterSet.length())).mapToObj(randomInt -> characterSet.substring(randomInt, randomInt + 1)).collect(Collectors.joining());
}

@Test
public void buildFiveRandomStrings() {
    for (int q = 0; q < 5; q++) {
        System.out.println(randomString(10, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));//charachterSet can basically be anything
    }
}

ou (um pouco mais legível caminho velho) 

public String randomString(int length, String characterSet) {
    StringBuilder sb = new StringBuilder(); //consider using StringBuffer if needed
    for (int i = 0; i < length; i++) {
        int randomInt = new SecureRandom().nextInt(characterSet.length());
        sb.append(characterSet.substring(randomInt, randomInt + 1));
    }
    return sb.toString();
}

@Test
public void buildFiveRandomStrings() {
    for (int q = 0; q < 5; q++) {
        System.out.println(randomString(10, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")); //charachterSet can basically be anything
    }
}

Mas, por outro lado, você também pode ir com o UUID que tem um bom entropia (https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions):

UUID.randomUUID().toString().replace("-", "")

Espero que ajude.

Você mencionar "simples", mas apenas no caso de alguém está olhando para algo que satisfaz mais rigorosos requisitos de segurança, você pode querer dar uma olhada em jpwgen.jpwgen é modelado após o pwgen no Unix, e é muito configurável.

Aqui é um fone de ouvido Scala solução:

(for (i <- 0 until rnd.nextInt(64)) yield { 
  ('0' + rnd.nextInt(64)).asInstanceOf[Char] 
}) mkString("")

Você pode usar o UUID classe com sua getLeastSignificantBits() mensagem para obter 64 bits de dados Aleatórios, em seguida, convertê-lo para uma base de 36 número (por exemplo,uma seqüência de caracteres consistindo de 0-9,A-Z):

Long.toString(Math.abs( UUID.randomUUID().getLeastSignificantBits(), 36));

Isso produz uma Seqüência de até 13 caracteres.Usamos a Matemática.abs() para certificar-se de que não há um sinal de menos de aprontar na.

Você pode usar o seguinte código , se a sua senha obrigatória contém números de alfabéticos caracteres especiais:

private static final String NUMBERS = "0123456789";
private static final String UPPER_ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static final String LOWER_ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
private static final String SPECIALCHARACTERS = "@#$%&*";
private static final int MINLENGTHOFPASSWORD = 8;

public static String getRandomPassword() {
    StringBuilder password = new StringBuilder();
    int j = 0;
    for (int i = 0; i < MINLENGTHOFPASSWORD; i++) {
        password.append(getRandomPasswordCharacters(j));
        j++;
        if (j == 3) {
            j = 0;
        }
    }
    return password.toString();
}

private static String getRandomPasswordCharacters(int pos) {
    Random randomNum = new Random();
    StringBuilder randomChar = new StringBuilder();
    switch (pos) {
        case 0:
            randomChar.append(NUMBERS.charAt(randomNum.nextInt(NUMBERS.length() - 1)));
            break;
        case 1:
            randomChar.append(UPPER_ALPHABETS.charAt(randomNum.nextInt(UPPER_ALPHABETS.length() - 1)));
            break;
        case 2:
            randomChar.append(SPECIALCHARACTERS.charAt(randomNum.nextInt(SPECIALCHARACTERS.length() - 1)));
            break;
        case 3:
            randomChar.append(LOWER_ALPHABETS.charAt(randomNum.nextInt(LOWER_ALPHABETS.length() - 1)));
            break;
    }
    return randomChar.toString();

}

Aqui é o código de uma linha por AbacusUtil

String.valueOf(CharStream.random('0', 'z').filter(c -> N.isLetterOrDigit(c)).limit(12).toArray())

Aleatórios, não significa que ele deve ser exclusivo.para obter seqüências de caracteres únicas, usando:

N.uuid() // e.g.: "e812e749-cf4c-4959-8ee1-57829a69a80f". length is 36.
N.guid() // e.g.: "0678ce04e18945559ba82ddeccaabfcd". length is 32 without '-'

usando o apache biblioteca pode ser feito em uma linha

import org.apache.commons.lang.RandomStringUtils;
RandomStringUtils.randomAlphanumeric(64);

aqui está o doc http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/RandomStringUtils.html

public static String randomSeriesForThreeCharacter() {
    Random r = new Random();
    String value="";
    char random_Char ;
    for(int i=0; i<10;i++)
    { 
        random_Char = (char) (48 + r.nextInt(74));
        value=value+random_char;
    }
    return value;
}

Eu acho que essa é a menor solução aqui, ou quase, um dos menores:

 public String generateRandomString(int length) {
    String randomString = "";

    final char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890".toCharArray();
    final SecureRandom random = new SecureRandom();
    for (int i = 0; i < length; i++) {
        randomString = randomString + chars[random.nextInt(chars.length)];
    }

    return randomString;
}

O código funciona muito bem.Se você estiver usando esse método, eu recomendo que você use mais do que 10 caracteres.A colisão acontece de 5 caracteres / 30362 iterações.Este demorou 9 segundos.

public static String getRandomString(int length) 
{
   String randomStr = UUID.randomUUID().toString();
   while(randomStr.length() < length) {
       randomStr += UUID.randomUUID().toString();
   }
   return randomStr.substring(0, length);
}

Talvez isso seja útil

package password.generater;

import java.util.Random;

/**
 *
 * @author dell
 */
public class PasswordGenerater {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int length= 11;
        System.out.println(generatePswd(length));

        // TODO code application logic here
    }
    static char[] generatePswd(int len){
        System.out.println("Your Password ");
        String charsCaps="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
        String Chars="abcdefghijklmnopqrstuvwxyz";
        String nums="0123456789";
        String symbols="!@#$%^&*()_+-=.,/';:?><~*/-+";
        String passSymbols=charsCaps + Chars + nums +symbols;
        Random rnd=new Random();
        char[] password=new char[len];

        for(int i=0; i<len;i++){
            password[i]=passSymbols.charAt(rnd.nextInt(passSymbols.length()));
        }
      return password;

    }
}
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top