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

Les nombres aléatoires sont couramment utilisés dans la création d'applications telles que des dés pour un jeu de société, un programme de jeu, etc. Normalement, la génération de nombres aléatoires prend beaucoup de temps. Mais, dans le langage de programmation Java, cela peut être réalisé de trois manières. Ils sont abordés dans la section ci-dessous Fonctions du générateur de nombres aléatoires en Java.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Fonctions du générateur de nombres aléatoires en Java

En Java, les nombres aléatoires peuvent être générés de 3 manières :

• Méthode Math.random
• java.util.Random class
• Classe ThreadLocalRandom

1. Méthode Math.random()

La classe Java Math propose un certain nombre de méthodes pour travailler sur des calculs tels que les logarithmes, la moyenne, l'exponentiation, etc. random() est l'une des méthodes parmi elles qui renvoie une valeur double positive comprise entre 0,0 et 1,0 où 0,0 est inclusif et 1.0 est exclusif. Cette méthode peut être utilisée avec ou sans paramètres. Si des paramètres sont donnés, le nombre aléatoire généré sera dans la plage du paramètre donné.

Exemple n°1

Code :

public class RandomNumber {
double num; //Declare a variable num
//Method which generates a random number
public double randnum()
{
num=Math.random();
return num;
}
// Main Method of a program
public static void main(String[] args) {
//Printing a random number
System.out.println("Random Number generated inside main method: "+Math.random());
//Create an object of the class RandomNumber
RandomNumber randomobj=new RandomNumber();
//Store the return value obtained from randnum method in a variable randomval
double randomval=randomobj.randnum();
//Printing the random number stored in variable randomval
System.out.println("Random Number generated inside randomnumber method: "+randomval);
}
}

Sortie :

Dans l'exemple ci-dessus, un nombre aléatoire est généré à l'aide de la méthode Math.random() de deux manières : en l'appliquant directement à l'intérieur de la méthode principale et en appelant une méthode qui contient Math.random() à l'aide de l'objet.  Comme mentionné dans l'explication ci-dessus, nous pouvons voir que 2 nombres aléatoires sont générés dans la plage de 0,0 et 1,0.

Pour générer un nombre aléatoire dans la plage de paramètres, l'expression générale utilisée est mentionnée ci-dessous :

Math.random()*  (( valeur max – valeur min ) +1 ) + valeur min

Exemple n°2

Où maxvalue est la limite supérieure de la plage et min value est la limite inférieure de la plage. Par exemple, afin de générer un nombre aléatoire entre 10 et 20, définissez la valeur maximale sur 20 et la valeur minimale sur 10.

Code :

public class RandomNumParameters {
public double randomnum(double x,double y)//max value-y, min value-x
{
double z =(Math.random()*((y-x)+1)+x); //Formula for random number generation within a range
return z;
}
public static void main(String[] args)
{
RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters
double num=ran.randomnum(3.0, 10.0); //Call the Method
System.out.println("Random number generated within the range of 3 and 10: "+num );
} }

Sortie :

2. java.util.Random Class

La classe Java.util.random génère des nombres aléatoires de différents types de données tels que float, long, entier, double, booléen, etc. Il est également possible de transmettre la plage de nombres comme arguments pour générer un nombre aléatoire dans cette plage . Pour utiliser cette classe, la classe Random de java.util doit être importée (java.util.Random). Une fois cette classe importée, créez une instance et appelez les méthodes telles que next long(), nextInt(), etc. en utilisant cette instance.

Exemple

Code :

//Java program to generate Random numbers using Random class
package Sample;
import java.util.Random; //import Random Class
public class RandomNum {
public static void main(String[] args) {
Random rand=new Random(); //Create instance of Random class
double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable
System.out.println("Random Double value: "+ randomnum);
}
}

Sortie :

Dans le programme ci-dessus, une valeur double aléatoire est générée à l'aide de la méthode nextDouble().

3. Classe ThreadLocalRandom

La classe ThreadLocalRandom est un type spécialisé de classe Random introduit dans la version 1.7 de Java. ThreadLocalRandom.current().nextInt() est l'une des méthodes courantes utilisées pour générer des nombres aléatoires. Il est normalement utilisé dans les applications multithread.

Exemple

Code :

//Java Program to generate random numbers using ThreadLocalRandom Class
import java.util.concurrent.ThreadLocalRandom;
public class RandomNumThread {
public static void main(String[] args) {
//print a random double
System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble());
}
}

Sortie :

Génération d'entiers

Des entiers aléatoires peuvent être générés à l'aide de la classe ThreadLocalRandom et de la classe Random. Dans les deux cas, une méthode nextInt() est utilisée pour le même :

Exemple

Code :

//Java program to generate Random integer numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomInteger {
public static void main(String[] args) {
Random rnd=new Random(); //Create instance of Random class
int randomnum1=rnd.nextInt(); //Random Integer value using Random Class
int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30
int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class
System.out.println("Random Integer value using Random Class: "+ randomnum1);
System.out.println("Random Integer value within the range of 30: "+ randomnum2);
System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3);
}
}

Sortie :

Dans l'exemple ci-dessus, trois nombres de type entier aléatoire sont générés où l'une des méthodes nextInt() a 30 comme argument. Ainsi, lors de la génération d'un nombre aléatoire, 30 sera défini comme limite supérieure et zéro (limite inférieure par défaut) sera défini comme limite inférieure.

Génération de nombres à virgule flottante

Semblable à la génération de nombres entiers, les nombres à virgule flottante peuvent être générés à l'aide d'une méthode nextFloat(). Cette méthode peut être utilisée à la fois dans Random Class et ThreadLocalRandom Class :

Exemple

Code :

//Java program to generate Random Float numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomFloat {
public static void main(String[] args) {
Random rnd=new Random(); //Create instance of Random class
float randomnum1=rnd.nextFloat(); //Random Float value using Random Class
float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class
System.out.println("Random float value using Random Class: "+ randomnum1);
System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2);
}
}

Sortie :

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

Java contient une multitude de fonctions qui peuvent être utilisées dans les programmes. Cela contribue à réduire le temps de traitement et les lignes de code. La génération de nombres aléatoires est une tâche dans laquelle nous pouvons utiliser certaines de ces fonctions. Ce document couvre les différentes méthodes pour y parvenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!