Comment générer une chaîne alphanumérique aléatoire ?
https://stackoverflow.com/questions/41107
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
j'ai cherché un simple Algorithme Java pour générer une chaîne alphanumérique pseudo-aléatoire.Dans ma situation, il serait utilisé comme un identifiant de session/clé unique qui serait "probablement" unique sur 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 à ceci : "AEYGF7K0DM1X".
La solution
Algorithme
Pour générer une chaîne aléatoire, concaténez des caractères tirés aléatoirement à partir de l'ensemble de symboles acceptables jusqu'à ce que la chaîne atteigne la longueur souhaitée.
Mise en œuvre
Voici un code assez simple et très flexible pour générer des identifiants aléatoires. Lisez les informations qui suivent pour des notes d'application importantes.
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);
}
}
Exemples d'utilisation
Créez un générateur non sécurisé pour les identifiants à 8 caractères :
RandomString gen = new RandomString(8, ThreadLocalRandom.current());
Créez un générateur sécurisé pour les identifiants de session :
RandomString session = new RandomString();
Créez 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);
Utiliser comme identifiants de session
Générer des identifiants de session susceptibles d'être uniques n'est pas suffisant, ou vous pouvez simplement utiliser un simple compteur.Les attaquants détournent les sessions lorsque des identifiants prévisibles sont utilisés.
Il existe une tension entre longueur et sécurité.Les identifiants plus courts sont plus faciles à deviner, car il y a moins de possibilités.Mais les identifiants plus longs consomment plus de stockage et de bande passante.Un plus grand ensemble de symboles est utile, mais peut entraîner des problèmes d'encodage si les identifiants sont inclus dans les URL ou saisis à nouveau à la main.
La source sous-jacente du caractère aléatoire, ou entropie, des identifiants de session doit provenir d'un générateur de nombres aléatoires conçu pour la cryptographie.Cependant, l'initialisation de ces générateurs peut parfois être coûteuse ou lente en termes de calcul, il convient donc de s'efforcer de les réutiliser lorsque cela est possible.
Utiliser comme identifiants d'objet
Toutes les applications ne nécessitent pas de sécurité.L'attribution aléatoire peut être un moyen efficace pour plusieurs entités de générer des identifiants dans un espace partagé sans aucune coordination ni partitionnement.La coordination peut être lente, en particulier dans un environnement en cluster ou distribué, et le fractionnement d'un espace entraîne des problèmes lorsque les entités se retrouvent avec des partages trop petits ou trop grands.
Les identifiants générés sans prendre de mesures pour les rendre imprévisibles doivent être protégés par d'autres moyens si un attaquant peut les visualiser et les manipuler, comme c'est le cas dans la plupart des applications Web.Il devrait y avoir un système d'autorisation distinct 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 identifiants suffisamment longs pour rendre les collisions improbables compte tenu du nombre total anticipé d'identifiants.C'est ce qu'on appelle « le paradoxe de l'anniversaire ». La probabilité d'une collision, p, est d'environ n2/(2qX), où n est le nombre d'identifiants réellement générés, q est le nombre de symboles distincts dans l'alphabet, et X est la longueur des identifiants.Cela devrait être un très petit nombre, comme 2‑50 ou moins.
Le calcul montre que le risque de collision entre 500 000 identifiants de 15 caractères est d'environ 2.‑52, ce qui est probablement moins probable que les erreurs non détectées provenant des rayons cosmiques, etc.
Comparaison avec les UUID
Selon leurs spécifications, les UUID ne sont pas conçus pour être imprévisibles, et ne devrait pas être utilisés comme identifiants de session.
Les UUID dans leur format standard prennent beaucoup de place :36 caractères pour seulement 122 bits d'entropie.(Tous les bits d'un UUID « aléatoire » ne sont pas sélectionnés de manière aléatoire.) Une chaîne alphanumérique choisie au hasard contient plus d'entropie en seulement 21 caractères.
Les UUID ne sont pas flexibles ;ils ont une structure et une disposition standardisées.C'est leur principale vertu ainsi que leur principale faiblesse.Lors de la collaboration avec un tiers, la standardisation offerte par les UUID peut être utile.Pour un usage purement interne, ils peuvent s’avérer inefficaces.
Autres conseils
Java fournit un moyen de le faire directement.Si vous ne voulez pas de tirets, ils sont faciles à supprimer.Utilisez simplement 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;
}
}
Sortir:
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 souhaitez utiliser les classes Apache, vous pouvez utiliser org.apache.commons.text.RandomStringGenerator (texte commun).
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.
En une seule 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 cela : RandomStringUtils
RandomStringUtils.randomAlphanumeric(20).toUpperCase();
Ceci est facilement réalisable sans aucune bibliothèque externe.
1.Génération de données cryptographiques pseudo-aléatoires
Vous avez d’abord besoin d’un PRNG cryptographique.Java a SecureRandom pour cela, on utilise généralement la meilleure source d'entropie sur la machine (par ex. /dev/random) . En savoir plus 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écurisé en Java, de générer des octets aléatoires.Je recommande cependant de NE PAS considérer les performances ici, car elles n'ont généralement aucun impact réel sur votre application, sauf si vous devez générer des millions de jetons par seconde.
2.Espace requis des valeurs possibles
Ensuite, vous devez décider « à quel point » votre jeton doit être unique.Le seul et unique intérêt de considérer l’entropie est de s’assurer que le système peut résister aux attaques par force brute :l'espace des valeurs possibles doit être si grand que tout attaquant ne peut essayer qu'une proportion négligeable des valeurs dans un temps non ridicule1.Identifiants uniques tels que aléatoires UUID avoir 122 bits 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 000 milliards d'UUID version 4 doivent être générés2". Nous choisirons 128 bits car il tient exactement dans 16 octets et est considéré comme largement suffisant pour être unique pour pratiquement tous les cas d'utilisation, sauf les plus extrêmes, et vous n'avez pas à penser aux doublons.Voici un tableau de comparaison simple de l'entropie comprenant une analyse simple de la problème d'anniversaire.
Pour des exigences simples, une longueur de 8 ou 12 octets peut suffire, mais avec 16 octets, vous êtes du « bon côté ».
Et c'est essentiellement tout.La dernière chose est de penser à l'encodage pour qu'il puisse être représenté sous forme de texte imprimable (lu, un String).
3.Encodage binaire vers texte
Les encodages typiques incluent :
Base64chaque caractère code sur 6 bits, créant une surcharge de 33 %.Heureusement, il existe des implémentations standards dans Java8+ et Android.Avec l'ancienne version de Java, vous pouvez utiliser n'importe lequel des de nombreuses bibliothèques tierces.Si vous souhaitez que vos jetons soient sécurisés par l'URL, utilisez le sécurisé pour les URL version de RFC4648 (qui est généralement prise en charge par la plupart des implémentations).Exemple de codage de 16 octets avec remplissage :XfJhfv3C0P6ag7y9VQxSbw==Base32chaque caractère code 5 bits, créant une surcharge de 40 %.Cela utiliseraA-Zet2-7ce qui le rend raisonnablement efficace en termes d'espace tout en étant alphanumérique insensible à la casse.Il n'y a pas implémentation standard dans le JDK.Exemple de codage de 16 octets sans remplissage :WUPIL5DQTZGMF4D3NX5L7LNFOYBase16(hex) chaque caractère code sur 4 bits nécessitant 2 caractères par octet (c.-à-d.16 octets créent une chaîne de longueur 32).Par conséquent, l'hexagone est moins efficace en termes d'espace queBase32mais il est sûr à utiliser dans la plupart des cas (url) puisqu'il utilise uniquement0-9etAàF.Exemple de codage sur 16 octets :4fa3dd0f57cb3bf331441ed285b27735. Voir une discussion SO sur la conversion en hexadécimal ici.
Encodages supplémentaires comme Base85 et l'exotisme Base122 existent avec une meilleure/pire efficacité spatiale.Vous pouvez créer votre propre encodage (ce que font essentiellement la plupart des réponses de ce fil), mais je vous le déconseille si vous n'avez pas d'exigences très spécifiques.Voir plus de schémas de codage dans l'article Wikipédia.
4.Résumé et exemple
- Utiliser
SecureRandom - Utilisez au moins 16 octets (2 ^ 128) de valeurs possibles
- Encodez selon vos besoins (généralement
hexoubase32si vous avez besoin qu'il soit alphanumérique)
Ne le faites pas
- ...utilisez l'encodage de votre bière maison : mieux maintenable et lisible pour les autres s'ils voient quel encodage standard vous utilisez au lieu d'étranges boucles for créant des caractères à la fois.
- ...utilisez l'UUID : il n'a aucune garantie sur le caractère aléatoire ;vous gaspillez 6 bits d'entropie et avez une représentation sous forme de chaîne verbeuse
Exemple:Générateur de jetons hexagonaux
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:Générateur de jetons Base64 (Url Safe)
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
Exemple:Outil CLI Java
Si vous souhaitez un outil cli prêt à l'emploi, vous pouvez utiliser des dés : https://github.com/patrickfav/dice
en utilisant Dollar devrait être simple comme suit :
// "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));
}
}
ça donne quelque chose comme ça :
DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7
Le 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 d'exécution :
scala> RandomAlphaNum.gen(42)
res3: java.lang.String = uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy
Étonnamment, personne ici ne l'a suggéré mais :
import java.util.UUID
UUID.randomUUID().toString();
Facile.
L'avantage de ceci est que les UUID sont beaux et longs et garantis presque impossibles à entrer en collision.
Wikipédia en donne une bonne explication :
"... seulement après avoir généré 1 milliard d'UUID chaque seconde pendant les 100 prochaines années, la probabilité de créer un seul 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, vous obtenez donc 122 bits aléatoires.Alors si tu vouloir vous pouvez tronquer à partir de la fin pour réduire la taille de l'UUID.Ce n'est pas recommandé, mais vous avez toujours beaucoup de hasard, suffisamment pour que vos 500 000 enregistrements soient faciles.
Une solution courte et simple, mais qui utilise uniquement 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 en 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;
}
L'utilisation des UUID n'est pas sécurisée, car certaines parties de l'UUID ne sont pas du tout aléatoires.La procédure de @erickson est très soignée, mais ne crée pas de chaînes de 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 de 0 à 9 et les caractères de a à z, nous aurions besoin d'un nombre aléatoire entre 0 et 35 pour obtenir un de chaque caractère. BigInteger fournit un constructeur pour générer un nombre aléatoire, uniformément réparti sur la plage 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 numéros « inutiles » / « plus longs ».Donc 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'une certaine longueur, nous pouvons simplement utiliser un 2^(length*numBits)-1 nombre.Le dernier problème, si nous voulons une chaîne d'une certaine longueur, aléatoire pourrait générer un petit nombre, donc la longueur n'est pas respectée, nous devons donc remplir la chaîne à la longueur requise en ajoutant 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, cela fait simplement ajouter le mot de passe dans la chaîne et...ouais, ça marche bien, regarde-le...très simple.je l'ai écrit
J'ai trouvé cette solution qui génère une chaîne codée en hexadécimal aléatoire.Le test unitaire fourni semble correspondre à mon cas d'utilisation principal.Bien que cela soit légèrement plus complexe que certaines des 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;
}
}
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);
}
}
}
Modifiez les caractères de chaîne selon vos besoins.
La chaîne est immuable.Ici
StringBuilder.appendest plus efficace que la concaténation de chaînes.
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();
}
Je n'aime pas vraiment aucune de ces réponses concernant la solution "simple": S
J'opterais pour un simple ;), Java pur, une seule ligne (l'entropie est basée sur une 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 à l'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 également opter pour l'UUID qui a une assez bonne entropie (https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions):
UUID.randomUUID().toString().replace("-", "")
J'espère que cela pourra aider.
Voici une solution 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 64 bits de données aléatoires, puis les convertir en un nombre de base 36 (c'est-à-direune chaîne composée de 0-9,A-Z) :
Long.toString(Math.abs( UUID.randomUUID().getLeastSignificantBits(), 36));
Cela donne une chaîne pouvant contenir jusqu'à 13 caractères.Nous utilisons Math.abs() pour nous assurer qu'il n'y a pas de signe moins qui s'introduit.
Vous pouvez utiliser le code suivant, si votre mot de passe contient obligatoirement des chiffres et des caractères spéciaux alphabétiques :
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, en utilisant :
N.uuid() // e.g.: "e812e749-cf4c-4959-8ee1-57829a69a80f". length is 36.
N.guid() // e.g.: "0678ce04e18945559ba82ddeccaabfcd". length is 32 without '-'
en utilisant la bibliothèque Apache, cela peut être fait en une seule ligne
import org.apache.commons.lang.RandomStringUtils;
RandomStringUtils.randomAlphanumeric(64);
voici le 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;
}
Je pense que c'est la plus petite solution ici, ou presque l'une des plus petites :
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;
}
Le code fonctionne très bien.Si vous utilisez cette méthode, je vous recommande d'utiliser plus de 10 caractères.La collision se produit à 5 caractères / 30 362 itérations.Cela a pris 9 secondes.
public static String getRandomString(int length)
{
String randomStr = UUID.randomUUID().toString();
while(randomStr.length() < length) {
randomStr += UUID.randomUUID().toString();
}
return randomStr.substring(0, length);
}
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;
}
}
