¿Cómo generar una cadena alfanumérica aleatoria?

He estado buscando un algoritmo Java simple para generar una cadena alfanumérica pseudoaleatoria. En mi situación, se usaría como un identificador único de sesión / clave que “probablemente” sería único en una generación superior a 500K (mis necesidades realmente no requieren nada mucho más sofisticado). Idealmente, podría especificar una longitud según mis necesidades de exclusividad. Por ejemplo, una cadena generada de longitud 12 puede parecerse a "AEYGF7K0DM1X" .

Algoritmo

Para generar una cadena aleatoria, concatenar caracteres dibujados aleatoriamente desde el conjunto de símbolos aceptables hasta que la cadena scope la longitud deseada.

Implementación

Aquí hay un código bastante simple y muy flexible para generar identificadores aleatorios. Lea la información que sigue para obtener notas importantes sobre la 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

Cree un generador inseguro para identificadores de 8 caracteres:

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

Crear un generador seguro para identificadores de sesión:

 RandomString session = new RandomString(); 

Crea un generador con códigos fáciles de leer para imprimir. Las cadenas son más largas que las cadenas alfanuméricas completas para compensar el uso de menos símbolos:

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

Usar como identificadores de sesión

Generar identificadores de sesión que probablemente sean únicos no es lo suficientemente bueno, o simplemente usar un contador simple. Los atacantes secuestran sesiones cuando se usan identificadores predecibles.

Hay tensión entre longitud y seguridad. Los identificadores más cortos son más fáciles de adivinar, porque hay menos posibilidades. Pero los identificadores más largos consumen más almacenamiento y ancho de banda. Un conjunto más grande de símbolos ayuda, pero puede causar problemas de encoding si los identificadores se incluyen en las URL o se vuelven a introducir a mano.

La fuente subyacente de aleatoriedad, o entropía, para los identificadores de sesión debe provenir de un generador de números aleatorios diseñado para criptografía. Sin embargo, inicializar estos generadores a veces puede ser costoso o lento desde el punto de vista computacional, por lo que se debe intentar reutilizarlos cuando sea posible.

Usar como identificadores de objetos

No todas las aplicaciones requieren seguridad. La asignación aleatoria puede ser una forma eficiente para que múltiples entidades generen identificadores en un espacio compartido sin ninguna coordinación o partición. La coordinación puede ser lenta, especialmente en un entorno agrupado o distribuido, y la división de un espacio causa problemas cuando las entidades terminan con participaciones demasiado pequeñas o demasiado grandes.

Los identificadores generados sin tomar medidas para hacerlos impredecibles deberían protegerse por otros medios si un atacante pudiera verlos y manipularlos, como ocurre en la mayoría de las aplicaciones web. Debería haber un sistema de autorización separado que proteja los objetos cuyo identificador pueda ser adivinado por un atacante sin permiso de acceso.

También se debe tener cuidado de utilizar identificadores que sean lo suficientemente largos como para hacer que las colisiones sean poco probables dado el número total anticipado de identificadores. Esto se conoce como "la paradoja del cumpleaños". La probabilidad de una colisión, p , es aproximadamente n 2 / (2q x ), donde n es el número de identificadores realmente generados, q es el número de símbolos distintos en el alfabeto yx es la longitud de los identificadores. Este debería ser un número muy pequeño, como 2 -50 o menos.

Si se resuelve esto, la probabilidad de colisión entre los identificadores de 500k y 15 caracteres es de aproximadamente 2 -52 , lo que es probablemente menos probable que los errores no detectados de los rayos cósmicos, etc.

Comparación con UUIDs

De acuerdo con su especificación, los UUID no están diseñados para ser impredecibles y no deben usarse como identificadores de sesión.

Los UUID en su formato estándar ocupan mucho espacio: 36 caracteres para solo 122 bits de entropía. (No todos los bits de un UUID "aleatorio" se seleccionan aleatoriamente). Una cadena alfanumérica elegida al azar contiene más entropía en solo 21 caracteres.

UUIDs no son flexibles; tienen una estructura y un diseño estandarizados. Esta es su virtud principal, así como su principal debilidad. Al colaborar con un tercero, la estandarización que ofrecen los UUID puede ser útil. Para uso puramente interno, pueden ser ineficientes.

Java proporciona una forma de hacerlo directamente. Si no quiere los guiones, son fáciles de quitar. Solo use 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á contento de utilizar las clases de Apache, puede usar org.apache.commons.text.RandomStringGenerator (commons-text).

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/

Puede usar la biblioteca Apache para esto: RandomStringUtils

 RandomStringUtils.randomAlphanumeric(20).toUpperCase(); 

usar Dollar debería 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)); } } 

produce algo como eso:

 DKL1SBH9UJWC JH7P0IT21EA5 5DTI72EO6SFU HQUMJTEBNF7Y 1HCR6SKYWGT7 

Esto se puede lograr fácilmente sin bibliotecas externas.

1. Generación de datos pseudoaleatorios criptográficos

Primero necesitas un PRNG criptográfico. Java tiene SecureRandom para eso normalmente usa la mejor fuente de entropía en la máquina (p /dev/random Ej. /dev/random ). Leer más aquí.

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

Nota: SecureRandom es la forma más lenta pero más segura en Java de generar bytes aleatorios. Sin embargo, recomiendo NO considerar el rendimiento aquí ya que generalmente no tiene un impacto real en su aplicación a menos que tenga que generar millones de tokens por segundo.

2. Espacio requerido de valores posibles

Luego debes decidir “qué tan único” debe ser tu token. El único punto para considerar la entropía es asegurarse de que el sistema pueda resistir ataques de fuerza bruta: el espacio de valores posibles debe ser tan grande que cualquier atacante solo podría intentar una proporción insignificante de los valores en un tiempo no ridículo 1 . Los identificadores únicos como el UUID aleatorio tienen 122bit de entropía (es decir, 2 ^ 122 = 5.3×10 ^ 36) – la probabilidad de colisión es “* (…) para que haya una posibilidad de duplicación de uno en un billón, 103 billones Los UUID de la versión 4 se deben generar a 2 “. Elegiremos 128 bits ya que encaja exactamente en 16 bytes y se considera que son suficientes para ser únicos para prácticamente todos, pero los casos de uso más extremos, y no tiene que pensar en duplicados. Aquí hay una tabla de comparación simple de entropía que incluye un análisis simple del problema del cumpleaños .

comparación de tamaños de tokens

Para requisitos simples, una longitud de 8 o 12 bytes puede ser suficiente, pero con 16 bytes está en el “lado seguro”.

Y eso es básicamente eso. Lo último es pensar en la encoding para que pueda representarse como un texto imprimible (leer, una String ).

3. Codificación binaria a texto

Las codificaciones típicas incluyen:

  • Base64 cada carácter codifica 6 bits creando un 33% de sobrecarga. Desafortunadamente, no hay una implementación estándar en el JDK ( 7 y siguientes , hay en Android y Java 8+ ). Pero existen numerosas bibliotecas que agregan esto. El inconveniente es que el Base64 estándar no es seguro, por ejemplo. urls y como nombre de archivo en la mayoría de los sistemas de archivos que requieren encoding adicional (por ejemplo, encoding de url ) o la versión URL segura de Base64 . Ejemplo de encoding de 16 bytes con relleno: XfJhfv3C0P6ag7y9VQxSbw==

  • Base32 cada carácter codifica 5 bits creando un 40% de sobrecarga. Esto utilizará AZ y 2-7 lo que hace que sea razonablemente eficiente en el uso del espacio, al tiempo que es alfanumérico y no distingue entre mayúsculas y minúsculas. No hay una implementación estándar en el JDK . Ejemplo de encoding de 16 bytes sin relleno: WUPIL5DQTZGMF4D3NX5L7LNFOY

  • Base16 (hexadecimal) cada carácter codifica 4 bits que requieren 2 caracteres por byte (es decir, 16 bytes crean una cadena de longitud 32). Por lo tanto, el hex es menos eficiente que Base32 pero es seguro de usar en la mayoría de los casos (url) ya que solo usa 0-9 y A a F Ejemplo de encoding de 16 bytes: 4fa3dd0f57cb3bf331441ed285b27735 . Vea una discusión SO sobre la conversión a hexadecimal aquí.

Codificaciones adicionales como Base85 y el exótico Base122 existen con mejor / peor eficiencia de espacio. Puedes crear tu propia encoding (que básicamente la mayoría de las respuestas en este hilo lo hacen) pero te aconsejaría que no, si no tienes requisitos muy específicos. Vea más esquemas de encoding en el artículo de Wikipedia.

4. Resumen y ejemplo

  • Use SecureRandom
  • Use al menos 16 bytes (2 ^ 128) de valores posibles
  • Codifique según sus requisitos (generalmente hex o base32 si necesita que sea alfanumérico)

No lo hagas

  • … use su encoding de elaboración casera: mejor mantenible y legible para otros si ven qué encoding estándar utiliza en lugar de bucles raros para crear caracteres a la vez.
  • … use UUID: está desperdiciando 6bits de entropía y tiene una representación de cadena detallada

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: herramienta

Si quieres una herramienta cli lista para usar, puedes usar los dados: https://github.com/patrickfav/dice

Sorprendente nadie aquí lo ha sugerido pero:

 import java.util.UUID UUID.randomUUID().toString(); 

Fácil.

El beneficio de esto es que los UUID son agradables y largos y se garantiza que son casi imposibles de colisionar.

Wikipedia tiene una buena explicación de eso:

“… solo después de generar mil millones de UUID por segundo durante los próximos 100 años, la probabilidad de crear solo un duplicado sería de aproximadamente el 50%”.

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

Los primeros 4 bits son el tipo de versión y 2 para la variante, por lo que obtienes 122 bits de aleatorio. Entonces, si lo desea , puede truncar desde el final para reducir el tamaño del UUID. No es recomendable, pero todavía tiene un montón de aleatoriedad, suficiente para sus 500k registros fáciles.

Aquí está 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í hay una muestra de ejecución:

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

Una solución corta y fácil, pero usa solo 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 de aproximadamente 12 dígitos hasta la base 36 y no se puede mejorar aún más, de esa manera. Por supuesto, 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) .mapToObj((i) -> (char) i) .collect(StringBuilder::new, StringBuilder::append, 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 

El uso de UUID es inseguro, porque partes del UUID no son del todo aleatorios. El procedimiento de @erickson es muy claro, pero no crea cadenas de la misma longitud. El siguiente fragmento 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é elegir la length*5 . Supongamos el caso simple de una cadena aleatoria de longitud 1, por lo que un carácter aleatorio. Para obtener un carácter aleatorio que contenga todos los dígitos 0-9 y los caracteres az, necesitaríamos 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, distribuido uniformemente en el rango de 0 to (2^numBits - 1) . Lamentablemente, 35 no es un número que se puede recibir por 2 ^ numBits – 1. Entonces, tenemos dos opciones: O ir con 2^5-1=31 o 2^6-1=63 . Si seleccionáramos 2^6 obtendríamos una gran cantidad de números “innecesarios” / “más largos”. Por lo tanto, 2^5 es la mejor opción, incluso si perdemos 4 caracteres (wz). Para generar ahora una cadena de cierta longitud, simplemente podemos usar un número de 2^(length*numBits)-1 . El último problema, si queremos una cadena con una cierta longitud, al azar podría generar un número pequeño, por lo que la longitud no se cumple, por lo que debemos rellenar la cadena con su longitud requerida antes de los 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); } } 

Entonces, lo que hace es agregar la contraseña en la cadena y … sí funciona bien, échale un vistazo … muy simple. yo lo escribi

Encontré esta solución que genera una cadena aleatoria codificada en hexadecimal. La prueba unitaria provista parece cumplir mi caso de uso primario. Sin embargo, es un poco más complejo que algunas de las otras respuestas proporcionadas.

 /** * 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 
  1. Cambie caracteres de cadena según sus requisitos.

  2. La cadena 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(); } 
 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 

Realmente no me gusta ninguna de estas respuestas con respecto a la solución “simple”: S

Me gustaría un simple;), Java puro, un trazador de líneas (la entropía se basa en la longitud de cadena aleatoria y el conjunto de caracteres dado):

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

or (a bit more readable old way)

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

But on the other hand you could also go with UUID which has a pretty good entropy ( https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions ):

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

Espero que ayude.

Here it is a Scala solution:

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

You can use the UUID class with its getLeastSignificantBits() message to get 64bit of Random data, then convert it to a radix 36 number (ie a string consisting of 0-9,AZ):

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

This yields a String up to 13 characters long. We use Math.abs() to make sure there isn’t a minus sign sneaking in.

You can use following code , if your password mandatory contains numbers alphabetic special characters:

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

Here is the one line code by AbacusUtil

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

Random doesn’t mean it must be unique. to get unique strings, using:

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

You mention “simple”, but just in case anyone else is looking for something that meets more stringent security requirements, you might want to take a look at jpwgen . jpwgen is modeled after pwgen in Unix, and is very configurable.

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

using apache library it can be done in one line

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

here is doc http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/RandomStringUtils.html

Maybe this is helpful

 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 

Best Random String Generator Method

 public class RandomStringGenerator{ private static int randomStringLength = 25 ; private static boolean allowSpecialCharacters = true ; private static String specialCharacters = "!@$%*-_+:"; private static boolean allowDuplicates = false ; private static boolean isAlphanum = false; private static boolean isNumeric = false; private static boolean isAlpha = false; private static final String alphabet = "abcdefghijklmnopqrstuvwxyz"; private static boolean mixCase = false; private static final String capAlpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private static final String num = "0123456789"; public static String getRandomString() { String returnVal = ""; int specialCharactersCount = 0; int maxspecialCharacters = randomStringLength/4; try { StringBuffer values = buildList(); for (int inx = 0; inx < randomStringLength; inx++) { int selChar = (int) (Math.random() * (values.length() - 1)); if (allowSpecialCharacters) { if (specialCharacters.indexOf("" + values.charAt(selChar)) > -1) { specialCharactersCount ++; if (specialCharactersCount > maxspecialCharacters) { while (specialCharacters.indexOf("" + values.charAt(selChar)) != -1) { selChar = (int) (Math.random() * (values.length() - 1)); } } } } returnVal += values.charAt(selChar); if (!allowDuplicates) { values.deleteCharAt(selChar); } } } catch (Exception e) { returnVal = "Error While Processing Values"; } return returnVal; } private static StringBuffer buildList() { StringBuffer list = new StringBuffer(0); if (isNumeric || isAlphanum) { list.append(num); } if (isAlpha || isAlphanum) { list.append(alphabet); if (mixCase) { list.append(capAlpha); } } if (allowSpecialCharacters) { list.append(specialCharacters); } int currLen = list.length(); String returnVal = ""; for (int inx = 0; inx < currLen; inx++) { int selChar = (int) (Math.random() * (list.length() - 1)); returnVal += list.charAt(selChar); list.deleteCharAt(selChar); } list = new StringBuffer(returnVal); return list; } } 
 public static String getRandomString(int length) { String randomStr = UUID.randomUUID().toString(); while(randomStr.length() < length) { randomStr += UUID.randomUUID().toString(); } return randomStr.substring(0, length); } 
    Intereting Posts