Comment utiliser la méthode Math.random() en Java
La méthode Math.random() est l'une des méthodes Java les plus couramment utilisées pour générer un nombre numérique aléatoire. La classe java.lang est une classe intégrée dans Java.Math avec plusieurs procédures mathématiques, dont l'une est Math.random(). Étant donné que la méthode Math.random() est une méthode statique, elle peut être invoquée/appelée sans avoir à construire au préalable une instance de classe mathématique. La classe java.lang.Math propose plusieurs méthodes pour effectuer des opérations numériques de base telles que l'exponentielle, le logarithme, le carré. racine et fonctions trigonométriques.
Méthode Math.random() en Java
Le java.lang.Math.random() renvoie un double résultat de signe positif supérieur ou égal à 0,0 mais inférieur à 1,0. Les valeurs renvoyées sont sélectionnées de manière pseudo-aléatoire dans cette plage avec une distribution (à peu près) uniforme. Lorsque cette méthode est invoquée pour la première fois, elle crée un seul nouveau générateur de nombres pseudo-aléatoires, tout comme le nouveau java.util.Random.
Les vrais nombres aléatoires et les nombres pseudo-aléatoires sont deux types de nombres aléatoires générés par ordinateur. Des influences externes sont utilisées pour générer des nombres véritablement aléatoires. Par exemple, vous pouvez utiliser des bruits dans l'environnement pour générer une randomisation.
Cependant, générer un tel nombre vraiment aléatoire prend du temps. En conséquence, nous pouvons utiliser des nombres pseudo-aléatoires générés à l'aide d'une valeur de départ et d'un algorithme. Pour la plupart, ces nombres pseudo-aléatoires sont suffisants. Ils peuvent être utilisés en cryptographie, en créant des jeux comme des dés ou des cartes, et en générant des numéros OTP (mot de passe à usage unique), par exemple.
Ce nouveau générateur de nombres pseudo-aléatoires est utilisé pour tous les appels à cette méthode et nulle part ailleurs. Cette technique est correctement synchronisée pour permettre à de nombreux threads de l'utiliser correctement. Avoir le générateur de nombres pseudo-aléatoires de chaque thread peut atténuer les conflits si plusieurs threads doivent générer des nombres pseudo-aléatoires à un rythme élevé.
Déclaration
La déclaration pour java.lang.Math.random() est la suivante.
public static double random()
Valeur du retour
Cette méthode renvoie un double pseudo-aléatoire inférieur à 1,0 et supérieur ou égal à 0,0. Cet article vous donnera une explication complète des principes suivants liés à la méthode Math.random() :
Qu'est-ce que Math.random() et comment ça marche ?
C'est une méthode intégrée dans le package java.lang. Il s'agit d'une classe mathématique utilisée pour générer une valeur aléatoire de type de données double. Le nombre résultant sera inférieur à 1,0 et supérieur ou égal à 0,0.
Syntaxe pour les débutants
L'extrait suivant illustre la syntaxe fondamentale de la méthode Math.random() :
public static double random() {
} Que renvoie la méthode Math.random() ?
L'expression suivante vous aidera à mieux comprendre ce concept :
5.0 <= Math.random() < 7.5
Vous pouvez voir que 5.0 est inclus dans l'extrait ci-dessus. Cependant, 7.5 ne l'est pas. Cela signifie que la méthode Math.random() produit une valeur comprise entre 5,0 et 7,499999999.
Comment puis-je utiliser Math.random() pour acquérir une certaine plage de valeurs ?
Disons que nous souhaitons générer un nombre aléatoire entre 0 et 10. Est-ce possible ? Oui! La méthode Math.random() en Java peut être utilisée pour obtenir une certaine plage de valeurs, et tout ce que nous avons à faire est de multiplier la valeur renvoyée de la méthode Math.random() par la plage souhaitée. Ce concept est mieux compris si vous utilisez l'expression ci-dessous :
int randValue = (int) (Math.random() * 10);
Le code ci-dessus générera une plage de valeurs entre 0 et 10 au hasard (10 non inclus). Pour inclure dix également, la plage doit être spécifiée comme (n+1), c'est-à-dire 11 :
int randValue = (int) (Math.random() * 11);
L'extrait ci-dessus va maintenant créer des nombres aléatoires entre 0 et 10.
Comment utiliser Math.random() en Java
Regardons les exemples ci-dessous pour voir comment fonctionne la méthode Java Math.random(). Nous utiliserons la méthode Math.random() pour produire deux valeurs aléatoires dans cet exemple :
public class CodeRandomMethod
{
public static void main(String[] args)
{
double numOne = Math.random();
double numTwo = Math.random();
System.out.println("The First Value is: " + numOne);
System.out.println("The Second Value is: "+numTwo);
}
} Comme Math.random() fournit une valeur numérique aléatoire, nous obtiendrons un nombre différent à chaque fois que nous exécuterons ce code. Par exemple, considérez un autre scénario dans lequel vous devez générer une valeur aléatoire dans une certaine plage. Nous allons générer une valeur entière entre 0 et 10 (inclus) dans l'exemple ci-dessous :
public class CodeRandomMethod {
public static void main(String[] args) {
int numOne = (int) (Math.random() * 11);
System.out.println("The first value is: " + numOne);
}
} Nous obtiendrons un nombre aléatoire distinct dans la plage spécifiée à chaque fois que nous exécuterons ce programme.
Nous pouvons voir dans l'exemple de code suivant que la méthode Math.random() génère une valeur entière aléatoire à l'intérieur de la plage souhaitée, indiquant que notre application est appropriée. Nous avons vu que nous pouvons spécifier une plage de valeurs dans les exemples ci-dessus, mais la valeur de départ est toujours zéro.
Cependant, nous pouvons également spécifier la plage/valeur initiale, auquel cas la méthode Math.random() générera un nombre aléatoire entre (valeur initiale + (valeur finale-1)). L'extrait de code suivant peut vous aider à saisir ce concept :
public class CodeRandomMethod {
public static void main(String[] args) {
int numOne = 5 + (int) (Math.random() * 11);
System.out.println(" The first value is: " + numOne);
}
} La valeur initiale est "5" et la finale est "11" dans l'extrait ci-dessus. La méthode Math.random() va maintenant créer un nombre entre 5 et 15 (5 + (11-1)). La sortie valide la fonctionnalité de la méthode Math.random().
package com.codeunderscored;
import java.lang.*;
public class CodeMath {
public static void main(String[] args) {
//two double numbers at random
double xVal = Math.random();
double yVal = Math.random();
// print the numbers and print the higher one
System.out.println("The first random number is:" + xVal);
System.out.println("The second random number is:" + yVal);
System.out.println("The highest number is:" + Math.max(xVal, yVal));
}
} Utilisation de la classe Random pour générer des entiers
Il existe de nombreuses méthodes d'instance dans la classe Random qui génèrent des entiers aléatoires. Nous examinerons deux méthodes d'instance dans cette section :nextInt(int bound) et nextDouble().
Qu'est-ce que la méthode nextInt(int bound) et comment l'utiliser ?
nextInt(int bound) renvoie un entier pseudo-aléatoire de type int qui est inférieur à la valeur liée et supérieur ou égal à zéro. L'argument lié spécifie la plage. Si nous fixons la limite à 7, par exemple, nextInt(7) renverra une valeur de type int supérieure ou égale à zéro mais inférieure à quatre. Les sorties potentielles de nextInt(7) sont 0,1,2,3,4,5,6,7. Nous devrions construire un objet aléatoire pour accéder à cette méthode car il s'agit d'une méthode d'instance. Essayons.
public static void main(String[] args) {
// creation of a random object
Random randObject = new Random();
// it generates random numbers from 0 to 6
int numVal = randObject.nextInt(7);
System.out.println(numVal);
} Qu'est-ce que la méthode nextDouble() et comment l'utiliser ?
La fonction nextDouble(), comme Math.random(), renvoie un entier pseudo-aléatoire de type double supérieur ou égal à zéro et inférieur à un.
public static void main(String[] args) {
// creation of a Random object
Random randObject = new Random();
// creates a random number between 0.0 and 1.0.
double numVal = randObject.nextDouble();
System.out.println(numVal);
} Exemple :nombres aléatoires dans une plage
Trouver des nombres aléatoires à l'intérieur d'une plage est un cas d'utilisation populaire. Regardons un exemple où nous produirons au hasard un nombre entre 1 et 10.
public class CodeMath {
public static void main(String[] args) {
evaluateRandom();
}
private static void evaluateRandom() {
// Generation of random numbers from 10 to 20 (inclusive) 10 times
for (int i=10; i<20; i++) {
System.out.println(
(int)randomValueWithinRange(10,20)
);
}
}
private static double randomValueWithinRange(int smallest, int highest) {
assert smallest < highest;
int rangeVals = (highest - smallest) + 1;
return ((Math.random() * rangeVals) + smallest);
}
}
Exemple :Math.random() en Java
class CodeUnderscoredMain {
public static void main(String[] args) {
// Math.random()
// This represents the first random value
System.out.println(Math.random());
// This represents the second random value
System.out.println(Math.random()); /
// This represents the third random value
System.out.println(Math.random());
}
} Nous pouvons voir que la méthode random() donne trois résultats différents dans l'exemple ci-dessus.
Exemple 2 :produire un nombre aléatoire entre cinquante et cinquante-cinq
class CodeRandomNumber {
public static void main(String[] args) {
int upperBoundValue = 55;
int lowerBoundValue = 50;
// upperBound 55 will also be included
int rangeValue = (upperBoundValue - lowerBoundValue) + 1;
System.out.println("Random Number values between 50 and 55:");
for (int i = 0; i < 5; i ++) {
// generation of a random number
// (int) conversion of double value to int
// Math.random() is responsible for generation of values between 50.0 and 55.0
int random = (int)(Math.random() * rangeValue) + lowerBoundValue;
System.out.print(random + ", ");
}
}
} Exemple :Accéder aux éléments d'un tableau aléatoire
class CodeRandomMain {
public static void main(String[] args) {
// create an array
int[] arrayVals = {22, 42, 64, 14, 83, 37, 58, 11};
int lowerBoundValue = 0;
int upperBoundValue = arrayVals.length;
// arrayVals.length will excluded
int range = upperBoundValue - lowerBoundValue;
System.out.println("List of Random Array Elements:");
// 5 random array elements
for (int i = 0; i <= 5; i ++) {
// get random array index
int random = (int)(Math.random() * range) + lowerBoundValue;
System.out.print(arrayVals[random] + ", ");
}
}
} Alors, quelle méthode de génération de nombres aléatoires devriez-vous utiliser ?
La classe random est utilisée par Math.random(). Nous pouvons utiliser Math.random() si nous voulons des valeurs pseudo-aléatoires de type double dans notre application. Sinon, nous pouvons utiliser la classe random, qui a plusieurs méthodes pour générer des entiers pseudo-aléatoires de différentes sortes, y compris nextInt(), nextLong(), nextFloat() et nextDouble().
Conclusion
Pour générer une valeur double pseudo-aléatoire entre 0.0 et 1.0 en Java, utilisez la méthode Math.random() de la classe Math. Math.random() génère une valeur aléatoire. Par conséquent, il générera un numéro différent à chaque exécution d'un programme.
Une valeur aléatoire peut être créée dans une plage définie à l'aide de la méthode Math.random(). Cet article a exploré plusieurs fonctionnalités de la fonction Math.random(), y compris ce qu'elle est, ce qu'elle renvoie, comment définir une plage spécifique pour les entiers aléatoires et comment utiliser la méthode Math.random() en Java.
