Cómo generar un azar alfa-numérico cadena?

https://stackoverflow.com/questions/41107

09-06-2019
|

Pregunta

He estado buscando un simple Java algoritmo para generar una pseudo-aleatorio de la alfa-numérico cadena.En mi situación sería utilizado como una única sesión/identificador de la clave, que "probablemente" ser único sobre 500K+ la generación de mis necesidades no requieren algo mucho más sofisticado).

Idealmente, me gustaría ser capaz de especificar una longitud dependiendo de mi singularidad de las necesidades.Por ejemplo, una cadena generada de longitud 12 podría ser algo como "AEYGF7K0DM1X".

Solución

Algoritmo

Para generar una cadena aleatoria, concatenar caracteres extraídos al azar de entre el conjunto de aceptable símbolos hasta que la cadena llega a la longitud deseada.

La aplicación

He aquí algunos bastante simple y muy flexible código para la generación aleatoria de los identificadores. Lea la información que sigue para importante notas de aplicación.

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

}

Ejemplos de uso

Crear una inseguridad generador de 8 caracteres identificadores:

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

Crear un seguro de un generador de identificadores de sesión:

RandomString session = new RandomString();

Crear un generador con fácil-a-lea los códigos para la impresión.Las cadenas son más que completo cadenas alfanuméricas para compensar menos uso de los símbolos:

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

Utilizar como identificadores de sesión

La generación de identificadores de sesión que tienden a ser único no es lo suficientemente bueno, o podría simplemente utilizar un simple contador.Los atacantes secuestrar sesiones cuando la predicción se utilizan identificadores.

Existe una tensión entre la longitud y la seguridad.Más corto identificadores son más fáciles de adivinar, porque hay menos posibilidades.Pero ya los identificadores de consumir más espacio de almacenamiento y ancho de banda.De un mayor conjunto de símbolos de ayuda, pero puede causar problemas de codificación si los identificadores están incluidos en las direcciones Url o re-introducido por la mano.

La fuente subyacente de la aleatoriedad, o entropía, para identificadores de sesión debe venir de un generador de número aleatorio diseñado para la criptografía.Sin embargo, la inicialización de estos generadores a veces puede ser computacionalmente caro o lento, por lo que el esfuerzo debe ser hecho para volver a utilizarlos cuando sea posible.

Utilizar como identificadores de objeto

No todas las aplicaciones requiere seguridad.La asignación al azar puede ser una manera eficaz para varias entidades para generar identificadores en un espacio compartido sin ningún tipo de coordinación o particiones.La coordinación puede ser lento, especialmente en un clúster o entorno distribuido, y la división de un espacio a causa de problemas cuando las entidades terminar con las acciones que son demasiado pequeños o demasiado grandes.

Los identificadores generados sin tomar medidas para hacer de ellos impredecibles deben ser protegidos por otros medios, si un atacante podría ser capaz de ver y manipular, como sucede en la mayoría de las aplicaciones web.Debe haber una autorización independiente del sistema que protege los objetos cuyo identificador se puede adivinar por un atacante sin permiso de acceso.

El cuidado debe ser tomado para el uso de los identificadores que son el tiempo suficiente para hacer las colisiones improbable, dada la anticipados total número de identificadores.Esto se conoce como "la paradoja de cumpleaños." La probabilidad de una colisión, p, es aproximadamente n²/(2q^x), donde n es el número de identificadores de hecho generado, q es el número de los distintos símbolos en el alfabeto, y x es la longitud de los identificadores.Este debe ser un número muy pequeño, como el 2^‑50 o menos.

Trabajando de esta muestra que la probabilidad de colisión entre 500k de 15 caracteres identificadores es de aproximadamente 2^‑52, que es menos probable que los errores no detectados a partir de los rayos cósmicos, etc.

Comparación con los Uuid

De acuerdo a su especificación, Uuid no están diseñados para ser impredecibles, y no debe ser utilizadas como identificadores de sesión.

Los uuid en su formato estándar de tomar un montón de espacio:36 caracteres por sólo 122 bits de entropía.(No todos los bits de un "azar" UUID son seleccionados al azar.) Un elegido al azar cadena alfanumérica de paquetes de más de entropía en solo 21 caracteres.

Los uuid no son flexibles;tienen una estructura estandarizada y diseño.Esta es su principal virtud como así también su principal debilidad.Cuando se colabora con una parte externa, la normalización de las ofrecidas por los Uuid puede ser útil.Sólo por el mero uso interno, que puede ser muy ineficiente.

Otros consejos

Java proporciona una manera de hacerlo directamente.Si no desea que los guiones, que son fáciles de quitar.Sólo uso 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;
    }
}

Salida:

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

Si estás feliz utilizar Apache clases, se podría utilizar org.apache.commons.text.RandomStringGenerator (commons de texto).

Ejemplo:

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 está en desuso.

En una línea:

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

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

Usted puede utilizar Apache biblioteca para esto: RandomStringUtils

RandomStringUtils.randomAlphanumeric(20).toUpperCase();

Esto es fácilmente alcanzable sin ningún tipo de bibliotecas externas.

1.Criptográfico Pseudo Aleatorio De Generación De Datos

En primer lugar usted necesita un criptográficos PRNG.Java tiene SecureRandom para que se utiliza normalmente en el mejor de entropía de la fuente en la máquina (por ejemplo, /dev/random) . Leer más aquí.

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

Nota: SecureRandom es la más lenta, pero más segura en Java de generación de bytes aleatorios.Yo, sin embargo, recomendamos NO teniendo en cuenta el rendimiento de aquí ya que por lo general no tiene ningún impacto real en su aplicación, a menos que usted tiene para generar millones de fichas por segundo.

2.Se requiere Espacio de Posibles Valores

Usted tiene que decidir "cómo único" el token debe ser.La totalidad y solo punto de considerar la entropía es para asegurarse de que el sistema puede resistir ataques de fuerza bruta:el espacio de posibles valores debe ser tan grande que cualquier atacante podría probar sólo una proporción insignificante de los valores de no-absurdo de tiempo¹.Identificadores únicos, como al azar UUID han 122bit de la entropía (es decir.2^122 = 5.3x10^36) - la probabilidad de colisión es "*(...) para que haya un uno en un billón de posibilidad de la duplicación, 103 billones de versión 4 Uuid debe ser generado²". Vamos a elegir 128 bits dado que se ajusta exactamente a 16 bytes y es visto como muy suficiente por ser única, fundamentalmente, para todos, pero los más extremos, casos de uso y usted no tiene que pensar acerca de duplicados.Aquí es una simple tabla de comparación de la entropía, incluyendo una simple análisis de la problema del cumpleaños.

^{Para los requisitos simples de 8 o 12 bytes de longitud podría ser suficiente, pero con 16 bytes que están en el "lado seguro".}

Y esa es básicamente la misma.La última cosa es pensar acerca de la codificación por lo que puede ser representado como un texto imprimible (leer, un String).

3.Binario de Codificación de Texto

Típico codificaciones incluyen:

Base64 cada carácter se codifica 6bit la creación de un 33% por encima.Afortunadamente, existen implementaciones estándar en Java 8+ y Android.Con mayores Java puede utilizar cualquiera de los numerosas bibliotecas de terceros.Si quieres que tu vales para ser la url de un uso seguro de la url-caja de seguridad la versión de RFC4648 (que generalmente es apoyado por la mayoría de las implementaciones).Ejemplo de codificación de 16 bytes con relleno: XfJhfv3C0P6ag7y9VQxSbw==
Base32 cada carácter se codifica 5bit la creación de un 40% de sobrecarga.Esto va a utilizar A-Z y 2-7 lo que es razonablemente uso eficiente del espacio, mientras que ser insensible a mayúsculas-alfa-numérico.No hay la implementación estándar en el JDK.Ejemplo de codificación de 16 bytes, sin relleno: WUPIL5DQTZGMF4D3NX5L7LNFOY
Base16 (hex) que cada carácter se codifica 4bit que requieren de 2 caracteres por byte (es decir.De 16 bytes crear una cadena de longitud 32).Por lo tanto, hex es el espacio menos eficiente que Base32 pero es seguro de usar en la mayoría de los casos (url) ya que solo se utiliza la 0-9 y A a F.Ejemplo de codificación de 16 bytes: 4fa3dd0f57cb3bf331441ed285b27735. Véase una discusión acerca de la conversión a hexadecimal aquí.

Adicional codificaciones como Base85 y lo exótico Base122 existen con mejor o peor aprovechamiento del espacio.Usted puede crear su propia codificación (que básicamente la mayoría de las respuestas en este hilo) pero yo aconsejo, si usted no tiene requisitos muy específicos.Ver más esquemas de codificación en el artículo de la Wikipedia.

4.Resumen y Ejemplo

Uso SecureRandom
El uso de al menos 16 bytes (2^128) de los valores posibles
Codificar de acuerdo a sus necesidades (generalmente hex o base32 si usted necesita para ser el alfa-numérico)

...el uso de su casa de la cerveza de codificación: mejor mantenimiento y legible para los demás, si ellos ven lo que el estándar de codificación que utilice en su lugar extraño para los bucles de la creación de caracteres en un momento.
...usar UUID: no tiene garantías sobre la aleatoriedad;usted está perdiendo 6bits de la entropía y han detallado representación de cadena

Ejemplo:Hex Token Generator

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

Ejemplo:Base64 Token Generator (Url De La Caja Fuerte)

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

Ejemplo:Java Herramienta CLI

Si desea una lista-para-usar la cli herramienta que usted puede usar los dados: https://github.com/patrickfav/dice

el uso de Dólar debe ser simple 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));
    }
}

genera algo así como que:

DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7

Aquí es en 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();
  }
}

Aquí se muestra un ejemplo de ejecución:

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

Sorprende a nadie aquí ha sugerido que pero:

import java.util.UUID

UUID.randomUUID().toString();

Fácil.

El beneficio de esto es Uuid son agradables y largo y garantizado para ser casi imposible de colisión.

Wikipedia tiene una buena explicación de la misma:

"...sólo después de la generación de 1 mil millones de Uuid de cada segundo durante los próximos 100 años, la probabilidad de crear un duplicado sería de alrededor de un 50%".

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

Los 4 primeros bits son el tipo de versión y 2 de la variante de modo que usted obtiene 122 bits de forma aleatoria.Así que si usted quiero usted puede truncar desde el fin de reducir el tamaño de la UUID.No es recomendable, pero usted todavía tiene un montón de aleatoriedad, suficiente para su 500k registros fácil.

Un corto y fácil solución, pero sólo utiliza minúsculas y números:

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

El tamaño es aproximadamente de 12 dígitos a base de 36 y no puede ser mejorado aún más, de esa manera.Por supuesto, usted puede agregar varias instancias.

Una alternativa en Java 8 es:

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

El uso de los Uuid es inseguro, ya que partes de la UUID de arn no al azar en todo.El procedimiento de @erickson es muy linda, pero no la creación de cadenas de la misma longitud.El siguiente fragmento de código debería ser suficiente:

/*
 * 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 qué la elección de length*5.Supongamos el caso simple de una cadena aleatoria de longitud 1, así, un carácter aleatorio.Para obtener un carácter aleatorio que contiene todos los dígitos del 0 al 9 y los caracteres de la a a la z, que sería necesario un número aleatorio entre 0 y 35 para obtener uno de cada carácter. BigInteger proporciona un constructor para generar un número aleatorio uniformemente distribuido en el intervalo 0 to (2^numBits - 1).Por desgracia 35 hay un número que puede ser recibido por 2^numBits - 1.Así que tenemos dos opciones:Ir con 2^5-1=31 o 2^6-1=63.Si hemos de elegir 2^6 nos gustaría obtener una gran cantidad de "unnecesarry" / "no" de los números.Por lo tanto 2^5 es la mejor opción, incluso si perdemos 4 caracteres (w-z).Para generar una cadena de una longitud determinada, simplemente podemos utilizar un 2^(length*numBits)-1 número.El último problema, si queremos una cadena con una longitud determinada, al azar podría generar un número pequeño, por lo que la longitud no se cumple, por lo que tenemos a la almohadilla de la cadena a la longitud requerida anteponiendo ceros.

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

Lo que esto hace es agregar la contraseña en la cadena y ...sí funciona bien, check it out...muy simple.Lo escribí

Encontré esta solución que genera un hex al azar cadena codificada.La unidad de prueba parece contener hasta mi caso de uso principal.Aunque, es un poco más complejo que algunas de las respuestas que se dieron.

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

Cambio de Cadena de caracteres como por como sus requisitos.
String es inmutable.Aquí StringBuilder.append es más eficiente que la concatenación de cadenas.

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

No me gusta ninguna de las respuestas sobre este "simple" solución :S

Yo iría a por un simple ;), java puro, un forro (entropía se basa en el azar de la longitud de la cadena y el 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
    }
}

o (un poco más legible camino viejo)

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

Pero por otro lado también podría ir con UUID que tiene un muy buen nivel de entropía (https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions):

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

Espero que ayude.

Usted menciona "simple", pero sólo en caso de que alguien más está buscando algo que cumple con los más estrictos requisitos de seguridad, es posible que desee echar un vistazo a jpwgen.jpwgen se modela después de pwgen en Unix, y es muy configurable.

Aquí se trata de una Scala solución:

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

Usted puede utilizar el UUID de la clase con su getLeastSignificantBits() mensaje para obtener 64 bits de datos Aleatorios, a continuación, convertir a una base de 36 número (es decir,una cadena que consta de 0-9,a-Z):

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

Esto produce una Cadena de hasta 13 caracteres.Utilizamos las Matemáticas.abs() para asegurarse de que no hay un signo menos a escondidas.

Usted puede utilizar el código siguiente , si su contraseña obligatoria contiene los números de los alfabéticos, caracteres especiales:

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

}

Aquí está el código de una línea por AbacusUtil

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

Azar no significa que debe ser único.para obtener cadenas de caracteres, utilizando:

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

el uso de apache de la biblioteca se puede hacer en una sola línea

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

aquí es el 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;
}

Creo que esta es la más pequeña de la solución aquí, o cerca de uno de los más pequeños:

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

El código funciona bien.Si usted está utilizando este método, te recomiendo usar más de 10 caracteres.Colisión ocurre en 5 caracteres / 30362 iteraciones.Esto se llevó a 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);
}

Tal vez esto es ú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 bajo: CC-BY-SA con atribución

No afiliado a StackOverflow