Générer un nombre aléatoire entre deux bornes en java

Les nombres aléatoires sont utilisés dans différents domaines comme la simulation pour simuler un phénomène par exemple la chute d'un corps ou les jeux vidéo comme Sudoku dont la grille doit être différente de la partie précédente ou un tirage au sort, etc.

Java possède deux moyens pour générer les nombres aléatoires: La première est la classe java.util.Random et la deuxième est la méthode random(). Dans ce tutoriel, on va voir comment générer des entiers (integer) aléatoires situés dans un intervalle (entre deux bornes) en Java.

La méthode Math.random() en Java

La méthode random() est simple à utiliser, elle se trouve dans la classe java.lang.Math et retourne un double avec un signe positive supérieur à 0.0 et inférieur à 1.0. Le nombre généré est un double.

double nb;
nb = Math.random();
System.out.println(nb);
Exécution:

0.9610715687122661
Pour obtenir des nombres supérieurs à 1, multipliez le résultat par 10,100,1000...100000.

nb=nb*100;
96.10715687122661

La classe java.util.Random 

Cette classe est plus puissante parce qu'elle offre une génération de plusieurs types pseudo-aléatoire: entier, float, double, byte, boolean...

Générer des nombres entiers entre zéro et n en java

La méthode next(int n) génère un nombre uniformément situé entre 0 et n-1.

Random random = new Random();
int nb;
nb = random.nextInt(9);
Le constructeur Random crée un nouveau générateur de nombres. L'exécution de ce code retourne un chiffre entre 0 et 8 choisi par le générateur.

Générer des integer entre deux bornes en java

La borne inférieur sera additionnée avec le résultat:
nb = borne_inférieur + random(borne_superieur-borne_inférieur)

int genererInt(int borneInf, int borneSup){
   Random random = new Random();
   int nb;
   nb = borneInf+random.nextInt(borneSup-borneInf);
   return nb;
}

public static void main(String[] args) {
   System.out.println("intervalle[10, 20]: "+generer(10,20));
}

Exécution:

intervalle[10, 20]: 15

Générer des integer en utilisant la méthode random.nextBytes()

La méthode nexBytes(bytes[]) retourne un tableau de bytes aléatoire. Le nombre de bits est égale à la taille du tableau passé en argument.

byte[] genererBit(int taille){
    Random random = new Random();
    byte[] tbyte = new byte[taille];
    random.nextBytes(tbyte);
    return tbyte;
}
public static void main(String[] args) {
   byte[] tbyte = genererBit(20);
   for(byte bit:tbyte)
   System.out.print(" "+bit);
}
Exécution:

-8 16 -7 27 54 -44 -75 88 -91 -74 -124 10 -100 101 -96 -41 -101 71 33 74

Booléen

Le booléen a deux valeur: true ou false.

boolean genererBool(){
    Random random = new Random();
    return random.nextBoolean();
}

Générer des nombres Float et double en java

Comme dans la méthode random() de la classe Math, le chiffre est compris entre 0.0 et 1.0.

float genererFloat(){
   Random random = new Random();
   return random.nextFloat();
}
double genererDouble(){
    Random random = new Random();
    return random.nextDouble();
}
public static void main(String[] args) {
   System.out.println("float: "+genererDouble());
   System.out.println("double: "+genererFloat());
}
Exécution:

double: 0.8538674831662335
float: 0.46791792
En java, le double est stocké sur 8 octets et le float sur 4 octets.

Références:
Javadoc: java.until.Random class
Javadoc: Math.random() method
Generating random integers in a range with Java
java.util.Random.nextInt() Method



Partager cet article

Voir aussi: