Générateur de nombres aléatoires en Java

Aujourd’hui, nous allons voir comment générer un nombre aléatoire en Java. Parfois, nous avons besoin de générer des nombres aléatoires dans les programmes Java. Par exemple, un jeu de dés ou pour générer un identifiant de clé aléatoire pour le chiffrement, etc.

Générateur de nombres aléatoires en Java

Il existe de nombreuses façons de générer un nombre aléatoire en Java.

1. La classe java.util.Random peut être utilisée pour créer des nombres aléatoires. Elle propose plusieurs méthodes pour générer des entiers, des longs, des doubles, etc.
2. Nous pouvons également utiliser Math.random() pour générer un double. Cette méthode utilise internement la classe Java Random.
3. La classe java.util.concurrent.ThreadLocalRandom doit être utilisée pour générer un nombre aléatoire dans un environnement multithread. Cette classe fait partie du package Java Concurrent et a été introduite dans Java 1.7. Cette classe a des méthodes similaires à la classe Java Random.
4. La classe java.security.SecureRandom peut être utilisée pour générer un nombre aléatoire avec une forte sécurité. Cette classe fournit un générateur de nombres aléatoires cryptographiquement fort. Cependant, elle est lente dans le traitement. Donc, en fonction des exigences de votre application, vous devriez décider de l’utiliser ou non.

Générateur de nombres aléatoires Java

Jetons un coup d’œil à quelques exemples pour générer un nombre aléatoire en Java. Plus tard, nous examinerons également un programme d’exemple ThreadLocalRandom et SecureRandom.

1. Générer un entier aléatoire

Random random = new Random();

int rand = random.nextInt();

Oui, c’est aussi simple de générer un entier aléatoire en java. Lorsque nous créons l’instance Random, elle génère une longue valeur de graine qui est utilisée dans tous les appels de méthode nextXXX. Nous pouvons définir cette valeur de graine dans le programme, cependant, ce n’est pas nécessaire dans la plupart des cas.

// définir la longue valeur de graine en utilisant le constructeur Random
Random random = new Random(123456789);

// définir la longue valeur de graine en utilisant la méthode setter
Random random1 = new Random();
random1.setSeed(1234567890);

2. Nombre aléatoire Java entre 1 et 10

Parfois, nous devons générer un nombre aléatoire dans une plage. Par exemple, dans un jeu de dés, les valeurs possibles ne peuvent être comprises qu’entre 1 et 6 uniquement. Ci-dessous se trouve le code montrant comment générer un nombre aléatoire entre 1 et 10 inclusivement.

Random random = new Random();
int rand = 0;
while (true){
    rand = random.nextInt(11);
    if(rand !=0) break;
}
System.out.println(rand);

L’argument dans la méthode nextInt(int x) est exclu, donc nous devons fournir l’argument comme 11. De plus, 0 est inclus dans le nombre aléatoire généré, donc nous devons continuer à appeler la méthode nextInt jusqu’à ce que nous obtenions une valeur entre 1 et 10. Vous pouvez étendre le code ci-dessus pour générer le nombre aléatoire dans n’importe quelle plage donnée.

3. Générer un double aléatoire

Nous pouvons utiliser Math.random() ou la méthode nextDouble de la classe Random pour générer un nombre aléatoire double en Java.

Random random = new Random();

double d = random.nextDouble();

double d1 = Math.random();

4. Générer un flottant aléatoire

Random random = new Random();

float f = random.nextFloat();

5. Générer un long aléatoire

Random random = new Random();

long l = random.nextLong();

6. Générer un booléen aléatoire

Random random = new Random();

boolean flag = random.nextBoolean();

7. Générer un tableau de bytes aléatoires

Nous pouvons générer des octets aléatoires et les placer dans un tableau de bytes fourni par l’utilisateur en utilisant la classe Random. Le nombre d’octets aléatoires produits est égal à la longueur du tableau de bytes.

Random random = new Random();

byte[] randomByteArray = new byte[5];

random.nextBytes(randomByteArray);

System.out.println(Arrays.toString(randomByteArray)); // sample output [-70, -57, 74, 99, -78]

8. ThreadLocalRandom dans un environnement multi-thread

Voici un exemple simple montrant l’utilisation de ThreadLocalRandom dans un environnement multi-thread.

package com.journaldev.randomnumber;

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomExample {

	public static void main(String[] args) {
		Runnable runnable = new MyRunnable();

		for (int i = 0; i < 5; i++) {
			Thread t = new Thread(runnable);
			t.setName("MyRunnable-Thread-" + i);
			t.start();
		}
	}

}

class MyRunnable implements Runnable {

	@Override
	public void run() {
		String threadName = Thread.currentThread().getName();
		System.out.println(threadName + "::" + ThreadLocalRandom.current().nextInt());
	}

}

Voici un exemple de sortie de mon exécution du programme ci-dessus.

MyRunnable-Thread-0::-1744088963
MyRunnable-Thread-3::139405798
MyRunnable-Thread-1::1403710182
MyRunnable-Thread-2::-1222080205
MyRunnable-Thread-4::-185825276

Nous ne pouvons pas définir de valeur de graine pour une instance de ThreadLocalRandom, cela lèvera une UnsupportedOperationException. La classe ThreadLocalRandom dispose également de quelques méthodes utilitaires supplémentaires pour générer un nombre aléatoire dans une plage. Par exemple, pour générer un nombre aléatoire entre 1 et 10, nous pouvons le faire comme ci-dessous.

ThreadLocalRandom random = ThreadLocalRandom.current();
		
int rand = random.nextInt(1, 11);

ThreadLocalRandom dispose de méthodes similaires pour générer des valeurs longues et doubles aléatoires.

9. Exemple de SecureRandom

Vous pouvez utiliser la classe SecureRandom pour générer des nombres aléatoires plus sécurisés en utilisant l’un des fournisseurs répertoriés. Un exemple rapide de code SecureRandom est donné ci-dessous.

Random random = new SecureRandom();

int rand = random.nextInt();

System.out.println(rand);

C’est tout pour générer un nombre aléatoire dans un programme Java.

Vous pouvez télécharger le code exemple depuis notre référentiel GitHub.