Java fournit une façon de le faire directement. Si vous ne voulez pas les tirets, ils sont faciles à dépouiller. Il suffit d'utiliser 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;
    }
}

sortie:

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 vous êtes heureux D'utiliser les classes Apache, vous pouvez utiliser org.apache.commons.text.RandomStringGenerator (commons-text).

exemple:

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

Depuis commons-lang 3.6, RandomStringUtils est obsolète.

sur une ligne:

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

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

vous pouvez utiliser la bibliothèque Apache pour ceci: RandomStringUtils

RandomStringUtils.randomAlphanumeric(20).toUpperCase();

utilisant Dollar devrait être simple comme:

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

il produit quelque chose comme cela:

DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7

cela est facilement réalisable sans bibliothèques externes.

1. Cryptographiques Pseudo-Aléatoire De La Génération De Données

tout d'abord, vous avez besoin d'un PRNG cryptographique. Java a SecureRandom pour cela utilise typiquement la meilleure source d'entropie sur la machine (par exemple /dev/random ). pour en savoir plus, cliquez ici.

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

Note: SecureRandom est le moyen le plus lent, mais le plus sûr en Java de générer des octets aléatoires. Je recommande cependant de ne pas considérer la performance ici, car il n'a généralement pas d'impact réel sur votre application à moins que vous ayez à générer des millions de Jetons par seconde.

2. Espace requis des valeurs possibles

Ensuite, vous devez décider "uniques" votre jeton doit être. L'ensemble et le seul point de considérer entropie est de s'assurer que le système peut résister à des attaques de force brute: l'espace des valeurs possibles doit être si grand que n'importe quel attaquant pourrait seulement essayer une proportion négligeable des valeurs dans le temps non-ridicule ¹ . Les identificateurs uniques comme random UUID ont 122bit d'entropie (c.-à-d. 2^122 = 5.3x10^36) - le risque de collision est" (...) pour qu'il y ait une chance sur un milliard de duplication, 103 trillions version 4 UUIDs doit être produit ² ". nous allons choisir 128 bits car il s'adapte exactement dans 16 octets et est considéré comme très suffisant pour être unique pour l'essentiel tous, mais les cas les plus extrêmes, l'utilisation et vous ne devez pas penser à des doublons. Voici un tableau de comparaison simple de l'entropie comprenant une analyse simple du problème d'anniversaire .

^{pour des exigences simples, une longueur de 8 ou 12 octets pourrait suffire, mais avec 16 octets, vous êtes du côté "sûr".}

et c'est tout. La dernière chose à faire est de penser au codage pour qu'il puisse être représenté comme un texte imprimable (lire, un String ).

3. Codage binaire à texte

les codages typiques comprennent:

• Base64 chaque caractère encode 6bit créant un overhead de 33%. Malheureusement il n'y a pas d'implémentation standard dans le JDK ( 7 et moins - il y a dans Android et Java 8+ ). Mais de nombreuses bibliothèques existent qui ajoutent ceci. L'inconvénient est que la norme Base64 n'est pas sûr, par exemple. url et que nom de fichier dans la plupart des systèmes de fichiers nécessitant un encodage supplémentaire (par exemple "url encoding ) ou la version URL safe version de Base64 est utilisé . Exemple de codage de 16 octets avec remplissage: XfJhfv3C0P6ag7y9VQxSbw==

• Base32 chaque caractère encode 5bit créant un 40% overhead. Il utilisera A-Z et 2-7 ce qui le rendra raisonnablement efficace dans l'espace tout en étant alpha-numérique insensible à la casse. Il n'y a pas de mise en œuvre standard dans le JDK . Exemple de codage de 16 octets sans remplissage: WUPIL5DQTZGMF4D3NX5L7LNFOY

• Base16 (hex) chaque caractère encode 4bit nécessitant 2 caractères par octet (c.-à-d. 16 octets créer une chaîne de longueur 32). Par conséquent, hex est moins économe en espace que Base32 mais est sûr à utiliser dans la plupart des cas (url) car il utilise uniquement 0-9 et A à F . Exemple de codage de 16 octets: 4fa3dd0f57cb3bf331441ed285b27735 . voir la discussion sur la conversion en hex ici.

des encodages supplémentaires comme Base85 et l'exotique Base122 existent avec une meilleure/moins bonne efficacité spatiale. Vous pouvez créer votre propre encodage (ce que font la plupart des réponses dans ce thread) mais je vous conseille de ne pas elle, si vous n'avez pas d'exigences particulières. Voir plus de schémas d'encodage dans L'article Wikipedia.

4. Résumé et exemple

• utilisation SecureRandom
• utiliser au moins 16 octets (2^128) de valeurs possibles
• Encoder selon vos exigences (habituellement hex ou base32 si vous avez besoin d'être alpha-numérique)

Ne pas

• ... utilisez votre maison Brew encoding: meilleur maintenable et lisible pour les autres si ils voient ce codage standard que vous utilisez au lieu de bizarre pour les boucles créant des caractères à la fois.
• ... utiliser l'UUID: vous perdez 6bits de l'entropie et ont détaillé représentation de chaîne

Exemple: Générateur De Tokens Hex

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

Exemple: Outil

si vous voulez un outil cli prêt à l'emploi vous pouvez utiliser des dés: https://github.com/patrickfav/dice

surprenant personne ici ne l'a suggéré mais:

import java.util.UUID

UUID.randomUUID().toString();

facile.

avantages de ce est UUIDs sont belles et longues et garanties d'être presque impossible à entrer en collision.

Wikipedia en a une bonne explication:

"...ce n'est qu'après avoir généré 1 milliard D'UUIDs chaque seconde pendant les 100 prochaines années, que la probabilité de créer juste un double serait d'environ 50%."

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

les 4 premiers bits sont le type de version et 2 pour la variante donc vous obtenez 122 bits de random. Donc si vous voulez à vous pouvez tronquer à partir de la fin pour réduire la taille de l'UUID. Ce n'est pas recommandé mais vous avez encore des tas d'aléas, assez pour vos 500K disques faciles.

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

voici un exemple:

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

une solution courte et facile, mais n'utilise que des minuscules et des chiffres:

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

la taille est d'environ 12 chiffres à la base 36 et ne peut pas être améliorée davantage, de cette façon. Bien sûr, vous pouvez ajouter plusieurs instances.

une alternative en Java 8 est:

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

utilisant UUIDs est peu sûr, parce que les parties de L'arn UUID ne sont pas aléatoires du tout. La procédure de @erickson est très soignée, mais ne crée pas de chaînes de la même longueur. L'extrait suivant devrait suffire:

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

Pourquoi choisir length*5 . Supposons le cas simple d'une chaîne aléatoire de longueur 1, donc un caractère aléatoire. Pour obtenir un caractère aléatoire contenant tous les chiffres 0-9 et les caractères A-z, nous aurions besoin d'un nombre aléatoire entre 0 et 35 à obtenir un de chaque personnage. BigInteger fournit un constructeur pour générer un nombre aléatoire, uniformément distribué dans la gamme 0 to (2^numBits - 1) . Malheureusement 35 n'est pas un nombre qui peut être reçu par 2^numBits - 1. Nous avons donc deux options: Soit aller avec 2^5-1=31 ou 2^6-1=63 . Si nous choisissions 2^6 nous obtiendrions beaucoup de" unnecesarry " / "plus" numéros. Par conséquent 2^5 est la meilleure option, même si nous perdons 4 caractères (w-z). Pour maintenant générer une chaîne d'un certain longueur, nous pouvons simplement utiliser un nombre 2^(length*numBits)-1 . Le dernier problème, si nous voulons une chaîne avec une certaine longueur, random pourrait générer un petit nombre, donc la longueur n'est pas respectée, donc nous devons pad la chaîne à sa longueur requise en prédisant des zéros.

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

donc ce que cela fait est juste ajouter le mot de passe dans la chaîne de caractères et ... ouais fonctionne bien, check it out... très simple. Je l'ai écrit

j'ai trouvé cette solution qui génère une chaîne encodée HEX au hasard. Le test unitaire fourni semble tenir jusqu'à mon cas d'utilisation principale. Bien que, il est un peu plus complexe que d'autres réponses fournies.

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

1. changez les caractères de chaîne selon vos exigences.

2. String is immuable. Ici StringBuilder.append est plus efficace que la concaténation de chaîne.

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

N'aimez pas vraiment aucune de ces réponses concernant la solution "simple": s

j'opterais pour un simple;), pur java, un liner (entropie est basée sur la longueur de chaîne aléatoire et le jeu de caractères donné):

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 (un peu plus lisible ancienne)

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

mais d'un autre côté vous pouvez aussi aller avec UUID qui a une entropie assez bonne ( https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions ):

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

Espère que ça aide.

ici, c'est une solution de Scala:

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

vous pouvez utiliser la classe UUID avec son message getLeastSignificantBits() pour obtenir 64bit de données aléatoires, puis le convertir en un nombre radix 36 (C.-à-d. une chaîne composée de 0-9,A-Z):

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

il s'agit d'une chaîne pouvant contenir jusqu'à 13 caractères. Nous utilisons les Mathématiques.abs() pour s'assurer qu'il n'y a pas de signe négatif.

vous pouvez utiliser le code suivant, si votre mot de passe obligatoire contient des caractères alphabétiques Spéciaux:

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

}

voici le code d'une ligne par AbacusUtil

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

Aléatoire ne signifie pas qu'il doit être unique. pour obtenir des chaînes uniques, Utilisez:

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

vous mentionnez" simple", mais juste au cas où quelqu'un d'autre est à la recherche de quelque chose qui répond aux exigences de sécurité plus strictes, vous pourriez jeter un oeil à jpwgen . jpwgen est modelé après pwgen dans Unix, et est très 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;
}

utilisation de la bibliothèque apache il peut être fait en une ligne

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

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

peut-être que c'est utile

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;

    }
}

Meilleure Méthode Du Générateur De Chaîne Aléatoire

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