web-dev-qa-db-fra.com

Existe-t-il une fonctionnalité permettant de générer un caractère aléatoire en Java?

Java dispose-t-il d'une fonctionnalité permettant de générer des caractères aléatoires ou des chaînes? Ou faut-il simplement choisir un entier aléatoire et convertir le code ascii de cet entier en caractère?

javarandom
50
Chris

Il existe de nombreuses façons de le faire, mais, oui, cela implique de générer une int aléatoire (en utilisant, par exemple, Java.util.Random.nextInt ), puis de mapper cela sur une char. Si vous avez un alphabet spécifique, alors quelque chose comme ça est chouette:

    import Java.util.Random;

    //...

    Random r = new Random();

    String alphabet = "123xyz";
    for (int i = 0; i < 50; i++) {
        System.out.println(alphabet.charAt(r.nextInt(alphabet.length())));
    } // prints 50 random characters from alphabet

Notez que Java.util.Random est en fait un pseudo - générateur de nombres aléatoires basé sur la formule plutôt faible de congruence linéaire . Vous avez parlé de la nécessité de la cryptographie. vous voudrez peut-être étudier l’utilisation d’un générateur de nombres pseudo-aléatoires bien sûr beaucoup plus puissant dans ce cas (par exemple, Java.security.SecureRandom ).

72
polygenelubricants

Pour générer un caractère aléatoire dans a-z:

Random r = new Random();
char c = (char)(r.nextInt(26) + 'a');
111
dogbane

Vous pouvez également utiliser RandomStringUtils du projet Apache Commons:

RandomStringUtils.randomAlphabetic(stringLength);
65
Josema
private static char rndChar () {
    int rnd = (int) (Math.random() * 52); // or use Random or whatever
    char base = (rnd < 26) ? 'A' : 'a';
    return (char) (base + rnd % 26);

}

Génère des valeurs dans les plages a-z, A-Z.

8
Peter Walser

En suivant 97 valeur ascii du petit "a". 

public static char randomSeriesForThreeCharacter() {
Random r = new Random();
char random_3_Char = (char) (97 + r.nextInt(3));
return random_3_Char;
}

en plus de 3 chiffres pour a, b, c ou d et si vous voulez tous les caractères comme a à z, vous remplacez 3 nombres par 25.

3
duggu

en utilisant dollar :

Iterable<Character> chars = $('a', 'z'); // 'a', 'b', c, d .. z

chars étant donné, vous pouvez créer une plage de caractères "mélangés":

Iterable<Character> shuffledChars = $('a', 'z').shuffle();

en prenant ensuite les premiers caractères n, vous obtenez une chaîne aléatoire de longueur n. Le code final est simplement:

public String randomString(int n) {
    return $('a', 'z').shuffle().slice(n).toString();
}

NB: la condition n > 0 est activée par slice

MODIFIER 

comme Steve l'a fait remarquer à juste titre, randomString utilise au plus une fois chaque lettre. Comme solution de contournementvous pouvez répéter l’alphabet m fois avant d’appeler shuffle:

public String randomStringWithRepetitions(int n) {
    return $('a', 'z').repeat(10).shuffle().slice(n).toString();
}

ou indiquez simplement votre alphabet sous la forme String:

public String randomStringFromAlphabet(String alphabet, int n) {
    return $(alphabet).shuffle().slice(n).toString();
}

String s = randomStringFromAlphabet("00001111", 4);
2
dfa
String abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char letter = abc.charAt(rd.nextInt(abc.length()));

Celui-ci fonctionne aussi bien.

2
Ricardo Vallejo

Vous l'avez. Générez simplement les codes aléatoires ASCII vous-même. Pourquoi en avez-vous besoin?

1
Strelok

Vous pouvez utiliser des générateurs du cadre de test basé sur les spécifications Quickcheck .

Pour créer une chaîne aléatoire, utilisez la méthode anyString .

String x = anyString();

Vous pouvez créer des chaînes à partir d'un ensemble de caractères plus restreint ou avec des restrictions de taille min/max.

Normalement, vous exécuteriez des tests avec plusieurs valeurs:

@Test
public void myTest() {
  for (List<Integer> any : someLists(integers())) {
    //A test executed with integer lists
  }
}
1
Thomas Jung

Essaye ça..

public static String generateCode() {

    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String fullalphabet = alphabet + alphabet.toLowerCase() + "123456789";
    Random random = new Random();

    char code = fullalphabet.charAt(random.nextInt(9));

    return Character.toString(code);

}
1
Sebo Molnár

C'est une découverte simple mais utile. Il définit une classe nommée RandomCharacter avec 5 méthodes surchargées pour obtenir un certain type de caractère de manière aléatoire. Vous pouvez utiliser ces méthodes dans vos projets futurs.

    public class RandomCharacter {
    /** Generate a random character between ch1 and ch2 */
    public static char getRandomCharacter(char ch1, char ch2) {
        return (char) (ch1 + Math.random() * (ch2 - ch1 + 1));
    }

    /** Generate a random lowercase letter */
    public static char getRandomLowerCaseLetter() {
        return getRandomCharacter('a', 'z');
    }

    /** Generate a random uppercase letter */
    public static char getRandomUpperCaseLetter() {
        return getRandomCharacter('A', 'Z');
    }

    /** Generate a random digit character */
    public static char getRandomDigitCharacter() {
        return getRandomCharacter('0', '9');
    }

    /** Generate a random character */
    public static char getRandomCharacter() {
        return getRandomCharacter('\u0000', '\uFFFF');
    }
}

Pour montrer comment cela fonctionne, examinons le programme de test suivant, qui affiche 175 lettres minuscules aléatoires.

public class TestRandomCharacter {
    /** Main method */
    public static void main(String[] args) {
        final int NUMBER_OF_CHARS = 175;
        final int CHARS_PER_LINE = 25;
        // Print random characters between 'a' and 'z', 25 chars per line
        for (int i = 0; i < NUMBER_OF_CHARS; i++) {
            char ch = RandomCharacter.getRandomLowerCaseLetter();
            if ((i + 1) % CHARS_PER_LINE == 0)
                System.out.println(ch);
            else
                System.out.print(ch);
        }
    }
}

et le résultat est:

 enter image description here 

si vous courez encore une fois:

 enter image description here 

Je donne crédit à Y.Daniel Liang pour son livre Introduction à la programmation Java, version complète, 10e édition, où j'ai cité ces connaissances et les a utilisées dans mes projets.

Note : Si vous n'êtes pas familier avec les méthodes surchargées, en bref Méthode La surcharge est une fonctionnalité qui permet à une classe d'avoir plusieurs méthodes portant le même nom, si leurs listes d'arguments sont différentes.

1
Gulbala Salamov

Je propose de générer une chaîne aléatoire avec des cas mélangés comme: "DthJwMvsTyu" .
Cet algorithme est basé sur les codes de lettres ASCII lorsque ses codes a-z (97 à 122) et A-Z (65 à 90) diffèrent par le cinquième bit (2 ^ 5 ou 1 << 5 ou 32).

random.nextInt(2): le résultat est 0 ou 1.

random.nextInt(2) << 5: le résultat est 0 ou 32.

Les valeurs supérieures A sont 65 et inférieures a est 97. La différence n’est que sur le cinquième bit (32). Par conséquent, pour générer un caractère aléatoire, nous effectuons une opération binaire OR '|' random charCaseBit (0 ou 32) et code aléatoire de A à Z (65 à 90).

public String fastestRandomStringWithMixedCase(int length) {
    Random random = new Random();
    final int alphabetLength = 'Z' - 'A' + 1;
    StringBuilder result = new StringBuilder(length);
    while (result.length() < length) {
        final char charCaseBit = (char) (random.nextInt(2) << 5);
        result.append((char) (charCaseBit | ('A' + random.nextInt(alphabetLength))));
    }
    return result.toString();
}
0
Marcin Programista

Jetez un coup d'oeil à Java Randomizer class ..__ Je pense que vous pouvez randomiser un caractère en utilisant la méthode randomize (char [] array).

0
manuel

La réponse des polygenelubricants est également une bonne solution si vous souhaitez uniquement générer des valeurs Hex:

/** A list of all valid hexadecimal characters. */
private static char[] HEX_VALUES = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F' };

/** Random number generator to be used to create random chars. */
private static Random RANDOM = new SecureRandom();

/**
 * Creates a number of random hexadecimal characters.
 * 
 * @param nValues the amount of characters to generate
 * 
 * @return an array containing <code>nValues</code> hex chars
 */
public static char[] createRandomHexValues(int nValues) {
    char[] ret = new char[nValues];
    for (int i = 0; i < nValues; i++) {
        ret[i] = HEX_VALUES[RANDOM.nextInt(HEX_VALUES.length))];
    }
    return ret;
}
0
schnatterer

Voici le code pour générer du code alphanumérique aléatoire. Tout d'abord, vous devez déclarer une chaîne de caractères autorisés, ce que vous souhaitez inclure dans un nombre aléatoire. Vous devez également définir la longueur maximale de la chaîne.

 SecureRandom secureRandom = new SecureRandom();
 String CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
    StringBuilder generatedString= new StringBuilder();
    for (int i = 0; i < MAXIMUM_LENGTH; i++) {
        int randonSequence = secureRandom .nextInt(CHARACTERS.length());
        generatedString.append(CHARACTERS.charAt(randonSequence));
    }

Utilisez la méthode toString () pour obtenir String à partir de StringBuilder

0
Abhishek Jha