Générer une chaîne aléatoire en Java

  1. Générer une chaîne aléatoire en Java avec l’expression régulière
  2. Générer une chaîne alphanumérique aléatoire en Java en utilisant la méthode Math.random()
  3. Génération en utilisant Charset
  4. Utiliser Apache Commons Lang

Une chaîne alphanumérique contient des caractères numériques et alphabétiques. En Java, il existe de nombreux cas où des chaînes alphanumériques sont utilisées. Par exemple, en générant un mot de passe après que l’utilisateur s’est inscrit sur une application; à générer une entrée de clé primaire pour identifier un élément dans une base de données; pour générer des identifiants de session, entre autres.

Cet article présente quatre méthodes pour générer une chaîne alphanumérique aléatoire en Java.

  1. l’expression régulière
  2. la méthode Math.random()
  3. le Charset
  4. Apache Commons Lang

Générer une chaîne aléatoire en Java avec l’expression régulière

Cette méthode est simple et donne une chaîne alphanumérique contenant des majuscules en minuscules et des chiffres.

La première chose à faire est de prendre des caractères compris entre 0 et 256.

La deuxième étape consiste à filtrer les caractères à laisser avec les éléments que nous voulons inclure dans notre chaîne aléatoire. Gardez à l’esprit que les caractères avec lesquels nous voulons rester sont 0-9 et A-Z, afin que nous puissions créer un filtre qui supprime tous les autres caractères.

L’étape suivante consiste à sélectionner les caractères aléatoires et à les ajouter à un StringBuffer. Nous créons ensuite un String à partir du StringBuffer en utilisant la méthode toString().

Voici un exemple de code.

import java.nio.charset.*;
import java.util.*;

class GenerateAlphaNumericString {
    static String getRandomString(int i) 
    { 
    
        // bind the length 
        bytearray = new byte[256];         byte[] bytearray;
        String mystring;
        StringBuffer thebuffer;
        String theAlphaNumericS;

        new Random().nextBytes(bytearray); 

        mystring 
            = new String(bytearray, Charset.forName("UTF-8")); 
            
        thebuffer = new StringBuffer();
        
        //remove all spacial char 
        theAlphaNumericS 
            = mystring 
                .replaceAll("[^A-Z0-9]", ""); 

        //random selection
        for (int m = 0; m < theAlphaNumericS.length(); m++) { 

            if (Character.isLetter(theAlphaNumericS.charAt(m)) 
                    && (i > 0) 
                || Character.isDigit(theAlphaNumericS.charAt(m)) 
                    && (i > 0)) { 

                thebuffer.append(theAlphaNumericS.charAt(m)); 
                i--; 
            } 
        } 

        // the resulting string 
        return thebuffer.toString(); 
    } 

    public static void main(String[] args) 
    { 
        // the random string length
        int i = 15; 

        // output 
        System.out.println("A random string: " +  getRandomString(i)); 
    } 
}

Production:

A random string: 4H4V7FWP8ZUKEGW

Générer une chaîne alphanumérique aléatoire en Java en utilisant la méthode Math.random()

Il s’agit de créer manuellement une chaîne contenant tous les caractères possibles. Nous créons ensuite une chaîne aléatoire de longueur définie en sélectionnant des caractères et des chiffres dans la chaîne que nous avons créée précédemment.

Tout d’abord, nous avons défini les deux variables dont nous aurons besoin - le StringBuilder et String. La chaîne contiendra toutes les lettres de l’alphabet en majuscules et les chiffres de 0 à 9. Cette chaîne ne doit avoir aucun symbole ni espace car les index des caractères de la chaîne seront utilisés pour sélectionner des caractères au hasard.

Deuxièmement, définissez l’itération qui est limitée à la longueur de la chaîne aléatoire que nous voulons créer.

Troisièmement, générez un index aléatoire en utilisant la méthode Math.random(). Récupérez le caractère de la chaîne précédemment créée qui est la position de l’index générée aléatoirement et ajoutez-le au StringBuilder. Ensuite, nous pouvons obtenir la chaîne aléatoire du StringBuilder en utilisant la méthode toString().

Voici un exemple de code.

class AlphaNumericStringGenerator {
    static String getRandomString(int i) 
    { 
        String theAlphaNumericS;
        StringBuilder builder;
        
        theAlphaNumericS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                    + "0123456789"; 

        //create the StringBuffer
        builder = new StringBuilder(i); 

        for (int m = 0; m < i; m++) { 

            // generate numeric
            int myindex 
                = (int)(theAlphaNumericS.length() 
                        * Math.random()); 

            // add the characters
            builder.append(theAlphaNumericS 
                        .charAt(myindex)); 
        } 

        return builder.toString(); 
    } 

    public static void main(String[] args) 
    { 
        // the random string length
        int i = 15; 

        // output 
        System.out.println("A random string: " +  getRandomString(i)); 
    }
} 

Production:

A random string: BCQJPZLG3OC1MQD

Génération en utilisant Charset

Nous utilisons le Charset, qui se trouve dans le package java.nio.charset. Un jeu de caractères représente un jeu de caractères et représente un mappage entre des caractères et des nombres. Le processus de création d’une chaîne alphanumérique à l’aide de Charset est expliqué ci-dessous.

La première étape consiste à prendre des caractères compris entre 0 et 256. La méthode Random() est ensuite appliquée au tableau des caractères ci-dessus. La troisième étape consiste à vérifier si chaque caractère est alphabétique ou numérique par itération. S’il s’agit de l’un d’entre eux, nous ajoutons ce caractère à la fin de la chaîne jusqu’à ce que nous atteignions la longueur définie. Les caractères ajoutés au StringBuilder sont convertis dans la chaîne souhaitée à l’aide de la méthode toString().

Voici un exemple de code.

import java.nio.charset.*;
import java.util.*; 

class AlphaNumericStringGenerator {
    static String getRandomString(int i) 
    { 

        byte[] bytearray;
        String mystring;
        StringBuffer thebuffer;
        
        bytearray = new byte[256]; 
        new Random().nextBytes(bytearray); 

        mystring 
            = new String(bytearray, Charset.forName("UTF-8")); 

        // Create the StringBuffer
        thebuffer = new StringBuffer(); 

        for (int m = 0; m < mystring.length(); m++) { 

            char n = mystring.charAt(m); 

            if (((n >= 'A' && n <= 'Z') 
                || (n >= '0' && n <= '9')) 
                && (i > 0)) { 

                thebuffer.append(n); 
                i--; 
            } 
        } 

        // resulting string 
        return thebuffer.toString(); 
    } 

    public static void main(String[] args) 
    { 
        // the random string length
        int i = 15; 

        // output 
        System.out.println("A random string: " +  getRandomString(i)); 
    }
}

Production:

A random string: XKT0JAHPRPZ6A3X

Utiliser Apache Commons Lang

C’est la méthode la plus simple à mettre en œuvre car un tiers gère l’implémentation, dans ce cas, le package Apache.

Le package Apache Commons Lang fournit de nombreux utilitaires d’assistance liés à la manipulation de chaînes en Java. Comme il s’agit d’un tiers, il doit d’abord être ajouté en tant que dépendance dans le projet.

On peut utiliser la classe RandomStringUtils pour générer la chaîne aléatoire Cette classe dispose de trois méthodes qui peuvent donner des chaînes aléatoires:

  1. RandomStringUtils.randomNumeric: crée une chaîne aléatoire de longueur spécifiée.
  2. RandomStringUtils.randomAlphabetic: créer une chaîne alphabétique aléatoire avec des caractères majuscules et minuscules
  3. RandomStringUtils.randomAlphanumeric: crée une chaîne alphanumérique aléatoire avec la longueur spécifiée.

Voici un exemple de code.

import org.apache.commons.lang3.RandomStringUtils;

public class Index {    
    public static void main(String[] args){
        System.out.println(RandomStringUtils.randomAlphanumeric(15)toUpperCase(););
    }
}

Production:

RM0WMYOKN7AS0KA

Le RandomStringUtils.randomAlphanumeric implémente directement l’alphanumérique aléatoire avec la possibilité d’avoir des alphabets en minuscules ou majuscules ou les deux. C’est un moyen efficace lorsque vous ne souhaitez pas implémenter la génération de chaîne dans votre code. La bibliothèque Apache est puissante et possède une foule d’autres fonctionnalités telles que les méthodes numériques de base, la concurrence et la réflexion d’objets.

Article connexe - Java String

  • Convertir une chaîne en tableau int en Java
  • Comment diviser une chaîne de caractères en Java