Java Random

La classe Random de Java est utilisée pour générer une série de nombres aléatoires.

Classe Random Java

• La classe Random fait partie du package java.util.
• Une instance de la classe Random de Java est utilisée pour générer des nombres aléatoires.
• Cette classe propose plusieurs méthodes pour générer des nombres aléatoires de type entier, double, long, flottant, etc.
• L’algorithme de génération de nombres aléatoires fonctionne sur la valeur de la graine (seed). Si aucune graine n’est fournie, la valeur de la graine est créée à partir du temps nano-système.
• Si deux instances de la classe Random ont la même valeur de graine, elles généreront alors la même séquence de nombres aléatoires.
• La classe Random de Java est thread-safe, cependant, dans un environnement multithread, il est conseillé d’utiliser la classe java.util.concurrent.ThreadLocalRandom.
• Les instances de la classe Random ne conviennent pas aux applications sensibles à la sécurité. Il est préférable d’utiliser la classe java.security.SecureRandom dans ces cas.

Constructeurs de la classe Random Java

La classe Random de Java a deux constructeurs qui sont les suivants:

1. Random(): crée un nouveau générateur aléatoire
2. Random(long seed): crée un nouveau générateur aléatoire en utilisant la graine spécifiée

Méthodes de la classe Random en Java

Jetons un coup d’œil à quelques-unes des méthodes de la classe Random en Java.

1. nextBoolean() : Cette méthode renvoie le prochain pseudorandom qui est une valeur booléenne de la séquence de générateur de nombres aléatoires.
2. nextDouble() : Cette méthode renvoie le prochain pseudorandom qui est une valeur double entre 0.0 et 1.0.
3. nextFloat() : Cette méthode renvoie le prochain pseudorandom qui est une valeur flottante entre 0.0 et 1.0.
4. nextInt() : Cette méthode renvoie la prochaine valeur int de la séquence de générateur de nombres aléatoires.
5. nextInt(int n) : Cette méthode renvoie un pseudorandom qui est une valeur int entre 0 et une valeur spécifiée de la séquence de générateur de nombres aléatoires.

Exemple de Random en Java

Jetons un coup d’œil au programme d’exemple Java Random ci-dessous.

package com.journaldev.examples;

import java.util.Random;

/**
 * Java Random Number Example Program
 * 
 */
public class RandomNumberExample {

	public static void main(String[] args) {
		
		// initialise le générateur de nombres aléatoires
		Random random = new Random();
		
		// génère une valeur booléenne
		System.out.println(random.nextBoolean());
		
		// génère une valeur double
		System.out.println(random.nextDouble());
		
		// génère une valeur flottante
		System.out.println(random.nextFloat());
		
		// génère une valeur int
		System.out.println(random.nextInt());
		
		// génère une valeur int within specific limit
		System.out.println(random.nextInt(20));

	}

}

La sortie du programme ci-dessus est :

false
0.30986869120562854
0.6210066
-1348425743
18

Consultez cet article pour en savoir plus sur la génération de nombres aléatoires en Java.

Générer un nombre aléatoire en utilisant une graine

Il existe deux façons de générer un nombre aléatoire en utilisant une graine.

Random random = new Random(long seed);
                         
Random random1 = new Random();
random1.setSeed(seed);

La graine est la valeur initiale de l’état interne du générateur de nombres pseudo-aléatoires qui est maintenu par la méthode next(int).

package com.journaldev.examples;

import java.util.Random;

/**
 * Java Random Number Using Seed Example Program
 * 
 * @author pankaj
 *
 */
public class RadomSeedExample {

	public static void main(String[] args) {
		
		//en utilisant le constructeur
		Random random = new Random(100);
		System.out.println("Using Constructor");
		System.out.println(random.nextInt());
		
		//en utilisant la méthode
		Random random2 = new Random();
		random2.setSeed(200);
		System.out.println("Using Method");
		System.out.println(random2.nextInt());
	}
}

Le résultat du programme ci-dessus est le suivant :

Using Constructor
-1193959466
Using Method
-1133938638

Que se passe-t-il si nous passons la même graine à deux générateurs de nombres aléatoires différents ? Jetons un coup d’œil au programme ci-dessous et voyons ce qui se passe si nous passons la même graine à deux générateurs de nombres aléatoires différents.

package com.journaldev.examples;

import java.util.Random;

/**
 * Java Random Number Using Same Seed Example Program
 * 
 */
public class RandomNumberSameSeedExample {

	public static void main(String[] args) {
		
		//initialiser deux générateurs de nombres aléatoires en utilisant la même graine
		Random random1 = new Random(100);
		Random random2 = new Random(100);
		
		System.out.println(random1.nextInt());
		System.out.println(random2.nextInt());

	}

}

Le résultat du programme ci-dessus est le suivant :

-1193959466
-1193959466

Nous pouvons constater qu’il générera le même nombre aléatoire si nous passons la même graine à deux générateurs de nombres aléatoires différents.

Méthodes de la classe Random de Java 8

Comme vous pouvez le voir sur l’image ci-dessus, de nombreuses nouvelles méthodes ont été ajoutées à la classe Random de Java 8. Ces méthodes peuvent produire un flux de nombres aléatoires. Ci-dessous se trouve un programme simple pour générer un flux de 5 entiers entre 1 et 100.

package com.journaldev.random;

import java.util.Random;
import java.util.stream.IntStream;

public class JavaRandomExample {

	public static void main(String[] args) {

		Random random = new Random();

		// générer un flux de 5 entiers entre 1 et 100
		IntStream ints = random.ints(5, 1, 100);

		ints.forEach(System.out::println);
	}

}

C’est tout pour un bref tour d’horizon sur la classe Random de Java. Référence : Documentation de l’API