Comment générer aléatoirement une chaîne alphanumérique?

j'ai recherché un algorithme Java simple pour générer une chaîne alphanumérique pseudo-aléatoire. Dans ma situation, il serait utilisé comme Identificateur de session/clé unique qui serait "probablement" unique au-dessus de 500K+ génération (mes besoins ne nécessitent pas vraiment quelque chose de beaucoup plus sophistiqué). Idéalement, je serais en mesure de spécifier une longueur en fonction de mes besoins uniques. Par exemple, une chaîne générée de longueur 12 pourrait ressembler à quelque chose comme "AEYGF7K0DM1X" .

1487
demandé sur Todd 2008-09-03 06:58:43
la source

30 ответов

algorithme

pour générer une chaîne de caractères aléatoire, concaténez les caractères tirés au hasard de l'ensemble des symboles acceptables jusqu'à ce que la chaîne atteigne la longueur désirée.

mise en œuvre

voici un code assez simple et très flexible pour générer des identificateurs aléatoires. lisez les renseignements qui suivent pour les notes importantes relatives à la demande.

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

}

Usage exemples

créer un générateur non sécurisé pour les identificateurs à 8 caractères:

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

créer un générateur sécurisé pour les identificateurs de session:

RandomString session = new RandomString();

créer un générateur avec des codes faciles à lire pour l'impression. Les chaînes sont plus longues que les chaînes alphanumériques complètes pour compenser l'utilisation de moins de symboles:

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

utilisation comme Identificateur de session

session génératrice les identificateurs qui sont susceptibles d'être unique n'est pas assez bon, ou vous pouvez simplement utiliser un simple compteur. Les attaquants détournent les sessions lorsque des identificateurs prévisibles sont utilisés.

il y a tension entre la longueur et la sécurité. Les identificateurs plus courts sont plus faciles à deviner, parce qu'il y a moins de possibilités. Mais les identificateurs plus longs consomment plus de stockage et de bande passante. Un plus grand ensemble de symboles aide, mais pourrait causer des problèmes d'encodage si les identificateurs sont inclus dans les URLs ou ré-entrés par main.

la source sous-jacente de l'aléatoire, ou entropie, pour les identificateurs de session devrait provenir d'un générateur de nombres aléatoires conçu pour la cryptographie. Toutefois, l'initialisation de ces générateurs peut parfois être coûteuse ou lente sur le plan informatique, de sorte qu'il faut s'efforcer de les réutiliser dans la mesure du possible.

utilisation comme Identificateur d'objet

toutes les applications ne nécessitent pas de sécurité. La répartition au hasard peut être un moyen efficace pour plusieurs entités pour générer des identificateurs dans un espace partagé sans aucune coordination ou partitionnement. La Coordination peut être lente, en particulier dans un environnement groupé ou distribué, et la division d'un espace pose des problèmes lorsque les entités finissent par avoir des parts trop petites ou trop grandes.

les identificateurs générés sans prendre de mesures pour les rendre imprévisibles devraient être protégés par d'autres moyens si un attaquant pourrait être en mesure de les visualiser et de les manipuler, comme cela se produit dans la plupart des sites web. application. Il devrait y avoir un système d'autorisation qui protège les objets dont l'identifiant peut être deviné par un attaquant sans autorisation d'accès.

il faut également veiller à utiliser des identificateurs suffisamment longs pour rendre les collisions peu probables compte tenu du nombre total prévu d'identificateurs. Ceci est appelé "le paradoxe d'anniversaire." la probabilité d'une collision, p , est d'environ n 2 /(2q x ), où n est le nombre d'identificateurs réellement générés, q est le nombre de symboles distincts dans l'alphabet, et x est la longueur des identificateurs. Cela devrait être un nombre très petit, comme 2 -50 ou moins.

ce travail montre que le risque de collision entre des identificateurs de 15 caractères de 500k est environ 2 -52 , ce qui est probablement moins probable que des erreurs non détectées des rayons cosmiques, etc.

comparaison avec UUIDs

selon leur spécification, les UUIDs ne sont pas conçus pour être imprévisibles, et ne doit pas être utilisé comme identificateurs de session.

Uuid dans leur format standard, prennent beaucoup d'espace: 36 caractères pour seulement 122 bits d'entropie. (Pas tous les bits d'un "hasard" Les UUID sont choisis au hasard.) Une chaîne alphanumérique choisie au hasard contient plus d'entropie en seulement 21 caractères.

Les UUID

ne sont pas flexibles; leur structure et leur disposition sont normalisées. C'est leur principale vertu ainsi que leur principale faiblesse. Lorsqu'on collabore avec une partie extérieure, la normalisation offerte par L'UUIDs peut être utile. Pour usage purement interne, ils peuvent être inefficaces.

1416
répondu erickson 2017-08-17 02:34:53
la source

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
746
répondu Steve McLeod 2017-08-30 09:09:52
la source
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();
}
474
répondu maxp 2016-02-25 13:41:59
la source

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.

457
répondu numéro6 2017-10-18 10:58:04
la source

sur une ligne:

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

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

94
répondu 3 revs, 3 users 71%anonymous 2015-10-29 05:29:50
la source

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

RandomStringUtils.randomAlphanumeric(20).toUpperCase();
89
répondu manish_s 2014-12-09 17:15:43
la source

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
38
répondu dfa 2015-10-29 05:30:13
la source

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 1 . 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 2 ". 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 .

comparison of token sizes

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

34
répondu for3st 2018-05-22 17:39:29
la source

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.

29
répondu Michael Allen 2014-04-16 15:49:00
la source

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
28
répondu Apocalisp 2008-09-03 21:16:38
la source

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.

22
répondu user unknown 2018-04-03 02:29:20
la source

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();
}
12
répondu Howard Lovatt 2018-10-03 22:09:43
la source
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;
}
8
répondu rina 2012-10-09 08:47:13
la source

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.

8
répondu Kristian Kraljic 2016-03-11 13:56:42
la source
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 = "[email protected]#$%^&*";
    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

7
répondu cmpbah 2012-04-17 13:42:20
la source

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);
        }
    }
}
5
répondu Todd 2015-08-20 09:49:20
la source
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;
    }
}
5
répondu Jameskittu 2015-08-20 09:50:34
la source
  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 = "[email protected]#$%^&*()_+";
       StringBuilder result = new StringBuilder();
       while(length > 0) {
           Random rand = new Random();
           result.append(characters.charAt(rand.nextInt(characters.length())));
           length--;
       }
       return result.toString();
    }
5
répondu frisky 2017-07-31 20:14:09
la source
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);
        }
    }
}
4
répondu Suganya 2015-08-20 09:51:18
la source

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.

4
répondu Patrik Bego 2018-02-21 18:55:12
la source

ici, c'est une solution de Scala:

(for (i <- 0 until rnd.nextInt(64)) yield { 
  ('0' + rnd.nextInt(64)).asInstanceOf[Char] 
}) mkString("")
3
répondu Ugo Matrangolo 2012-07-24 15:11:01
la source

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.

3
répondu neuhaus 2013-07-29 18:07:23
la source

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

}
3
répondu Prasobh.K 2015-08-20 09:52:26
la source

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 '-'
3
répondu Developer of AbacusUtil 2017-04-21 00:45:59
la source

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.

3
répondu michaelok 2017-06-27 01:47:13
la source
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;
}
3
répondu duggu 2018-04-03 02:30:48
la source

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

2
répondu hridayesh 2012-10-15 11:52:12
la source

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="[email protected]#$%^&*()_+-=.,/';:?><~*/-+";
        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;

    }
}
2
répondu 2 revs, 2 users 97%user5138430 2017-06-28 12:49:48
la source

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 = "[email protected]$%*-_+:";
    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;
    }   

}
1
répondu Bhavik Ambani 2012-04-28 11:33:52
la source
public static String getRandomString(int length) 
{
   String randomStr = UUID.randomUUID().toString();
   while(randomStr.length() < length) {
       randomStr += UUID.randomUUID().toString();
   }
   return randomStr.substring(0, length);
}
1
répondu Vin Ferothas 2012-12-03 10:59:05
la source

Autres questions sur java string random alphanumeric