Qu'est-ce que le générateur de nombres aléatoires en Java?
Les nombres aléatoires sont couramment utilisés dans la création d'applications comme les dés pour un jeu de société, le 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 traités dans la section ci-dessous Fonctions du générateur de nombres aléatoires en Java.
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
- classe java.util.Random
- 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 dans la plage de 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 utilisation de 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 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);
)
)
Production:
Dans l'exemple ci-dessus, Random Number 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 () * ((maxvalue - minvalue) +1) + minvalue
Exemple # 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 max sur 20 et la valeur min sur 10.
Code:
public class RandomNumParameters (
public double randomnum(double x, double y)//max value-y, min value-x
(
double z =(Math.random()*((yx)+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 );
) )
Production:
2. Classe java.util.Random
La classe Java.util.Random génère des nombres aléatoires de différents types de données tels que float, long, integer, double, Boolean, etc. Il est également possible de passer la plage de nombres comme arguments afin qu'un nombre aléatoire soit généré 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 1
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);
)
)
Production:
Dans le programme ci-dessus, une double valeur 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 qui est introduit dans Java version 1.7. 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 multi-thread.
Exemple 1
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());
)
)
Production:
Génération de nombres entiers
Des entiers aléatoires peuvent être générés à l'aide de la classe ThreadLocalRandom et de la classe aléatoire. Dans les deux cas, une méthode nextInt () est utilisée pour le même:
Exemple 1
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);
)
)
Production:
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 la classe aléatoire et la classe ThreadLocalRandom:
Exemple 1
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);
)
)
Production:
Conclusion
Java contient une multitude de fonctions qui peuvent être utilisées dans les programmes. Cela aide à réduire le temps de traitement et les lignes de code. La génération de nombres aléatoires est une tâche où nous pouvons utiliser certaines de ces fonctions. Ce document couvre les différentes méthodes pour y parvenir.
Articles recommandés
Ceci est un guide du générateur de nombres aléatoires en Java. Nous discutons ici des fonctions en java avec des exemples et deux générateurs différents. Vous pouvez également consulter nos autres articles connexes pour en savoir plus -
- Générateur de nombres aléatoires en Python
- Générateur de nombres aléatoires en C
- Générateur de nombres aléatoires en R
- Récursivité en Java
- Générateur de nombres aléatoires dans Matlab
- Générateur de nombres aléatoires en C #
- Tableaux en programmation Java
- Générateur de nombres aléatoires en JavaScript
- Générateur de nombres aléatoires en PHP