Java: Générer aléatoirement des noms distincts
J'ai besoin de générer 10 000 identifiants uniques en Java. Les identifiants doivent être un mélange de chiffres et de lettres et de moins de 10 caractères chacune. Des idées? Les bibliothèques intégrées seraient un plus supplémentaire.
8 answers
// class variable
final String lexicon = "ABCDEFGHIJKLMNOPQRSTUVWXYZ12345674890";
final java.util.Random rand = new java.util.Random();
// consider using a Map<String,Boolean> to say whether the identifier is being used or not
final Set<String> identifiers = new HashSet<String>();
public String randomIdentifier() {
StringBuilder builder = new StringBuilder();
while(builder.toString().length() == 0) {
int length = rand.nextInt(5)+5;
for(int i = 0; i < length; i++) {
builder.append(lexicon.charAt(rand.nextInt(lexicon.length())));
}
if(identifiers.contains(builder.toString())) {
builder = new StringBuilder();
}
}
return builder.toString();
}
Je réponds à cela très tard, mais c'est ce qui est vraiment utile pour le nouveau lecteur. C'est un moyen très simple et efficace d'obtenir noms VALIDES aléatoires. Pour ce faire, ajoutez le référentiel maven dans POM.xml
<dependency>
<groupId>com.github.javafaker</groupId>
<artifactId>javafaker</artifactId>
<version>0.12</version>
</dependency>
Puis utilisez la classe Faker comme ci-dessous dans votre code Java
Faker faker = new Faker();
String name = faker.name().fullName();
String firstName = faker.name().firstName();
String lastName = faker.name().lastName();
String streetAddress = faker.address().streetAddress();
Essayez d'imprimer le résultat en utilisant la norme System.out.println();
Pour plus de référence Faker Lib
Pourquoi ne pas utiliser java.util.UUID? Il est garanti de générer des identifiants uniques, et il est aussi standard que possible :-).
Si vous autorisez Apache Commons lang...
public String[] getRandomlyNames(final int characterLength, final int generateSize) {
HashSet<String> list = new HashSet<String>();
for (int i = 0; i < generateSize; ++i) {
String name = null;
do {
name = org.apache.commons.lang.RandomStringUtils.randomAlphanumeric(
org.apache.commons.lang.math.RandomUtils.nextInt(characterLength - 1) + 1);
while(list.contains(name));
list.add(name);
}
return list.toArray(new String[]{});
}
Vous pouvez essayer de prendre le hachage md5 de l'heure actuelle et vous obtiendrez un identifiant "aléatoire" comme mélange de chiffres et de lettres
Le moyen le plus simple et le plus rapide est de générer permutations d'une certaine chaîne. Tant que la chaîne est assez longue, vous pouvez facilement avoir 10 000 permutations uniques. La bonne chose de générer une permutation est que vous n'avez pas à vous soucier des duplications. Si une chaîne contient tous les caractères différents, elle peut générer n! permutations (n est la longueur de la chaîne). Ainsi, une chaîne avec 8 caractères différents peut générer 40 320 permutations différentes.
Il y en a beaucoup code en ligne pour générer des permutations d'une chaîne, comme celle-ci http://introcs.cs.princeton.edu/23recursion/Permutations.java.html .
Si vous voulez qu'ils soient plus aléatoires, vous pouvez utiliser différentes chaînes comme graine, telles que "abcde123", "efgh456", etc..
Vous pouvez essayer
Random rand = new Random();
Set<String> words = new HashSet<String>();
while(words.size() < 10000)
words.add(Long.toString(Math.abs(rand.nextLong() % 3656158440062976L), 36)));
La constante longue est juste suffisante pour les nombres à 10 chiffres, en base 36.
J'ai eu le même problème, mais j'avais besoin d'une chaîne arbitrairement longue. Je suis venu avec ce one-liner, aucune bibliothèque externe nécessaire, qui vous donnera 10 caractères:
BigInteger.probablePrime(50, new Random()).toString(Character.MAX_RADIX)
La longueur peut être modifiée, vous avez besoin d'environ 5 bits par caractère. Ce qui a fait est de filtrer et de limiter la longueur comme suit (juste des lettres minuscules, et la taille 10):
BigInteger.probablePrime(100, new Random()).
toString(Character.MAX_RADIX).
replaceAll("[0-9]", "").
substring(0, 10)
Inconvénient: c'est un peu lent.