Dans Java programmation, nous avions souvent besoin de générer des nombres aléatoires pendant que nous développons des applications. De nombreuses applications ont la fonctionnalité de générer des nombres au hasard , par exemple pour vérifier l'utilisateur, de nombreuses applications utilisent le Bureau du Procureur . Le meilleur exemple de nombres aléatoires est celui des dés. Parce que quand on le lance, on obtient un nombre aléatoire entre 1 et 6.

Dans cette section, nous apprendrons ce qu'est un nombre aléatoire et comment générer des nombres aléatoires dans Java .

Nombre aléatoire

Les nombres aléatoires sont les nombres qui utilisent un grand nombre de nombres et sélectionnent un nombre à l'aide de l'algorithme mathématique. Il remplit les deux conditions suivantes :

bash si instruction

• Les valeurs générées uniformément réparties sur un intervalle défini.
• Il est impossible de deviner la valeur future sur la base des valeurs actuelles et passées.

Générer un nombre aléatoire en Java

En Java, il existe trois façons de générer des nombres aléatoires en utilisant la méthode et les classes.

• En utilisant le aléatoire() Méthode
• En utilisant le aléatoire Classe
• En utilisant le SujetLocalAléatoire Classe
• En utilisant le entiers() Méthode (en Java 8)

Utilisation de la méthode Math.random()

Le Java Mathématiques La classe dispose de nombreuses méthodes pour différentes opérations mathématiques. L'un d'eux est le aléatoire() méthode. C'est un statique méthode du cours de Maths. Nous pouvons l'invoquer directement. Il génère uniquement double tapez un nombre aléatoire supérieur ou égal à 0,0 et moins de 1,0 . Avant d'utiliser la méthode random(), nous devons importer lejava.lang.Mathclasse.

Syntaxe:

 public static double random() 

Il n'accepte aucun paramètre. Il renvoie un double pseudo-aléatoire supérieur ou égal à 0,0 et inférieur à 1,0.

Créons un programme qui génère des nombres aléatoires en utilisant la méthode random().

RandomNumberExample1.java

 import java.lang.Math; public class RandomNumberExample1 { public static void main(String args[]) { // Generating random numbers System.out.println('1st Random Number: ' + Math.random()); System.out.println('2nd Random Number: ' + Math.random()); System.out.println('3rd Random Number: ' + Math.random()); System.out.println('4th Random Number: ' + Math.random()); } } 

Sortir:

 1st Random Number: 0.17434160924512265 2nd Random Number: 0.4297410090709448 3rd Random Number: 0.4828656381344487 4th Random Number: 0.13267917059488898 

Souviens-toi: Chaque fois que nous obtenons un résultat différent lorsque nous exécutons le programme. Votre sortie peut différer de la sortie affichée ci-dessus.

Nous pouvons également utiliser la formule suivante si nous voulons générer un nombre aléatoire entre une plage spécifiée.

 Math.random() * (max - min + 1) + min 

Dans la formule ci-dessus, la valeur minimale est inclusive tandis que la valeur maximale est exclusive.

Créons un programme qui génère des nombres aléatoires entre 200 et 400.

RandomNumberExample2.java

 public class RandomNumberExample2 { public static void main( String args[] ) { int min = 200; int max = 400; //Generate random double value from 200 to 400 System.out.println('Random value of type double between '+min+' to '+max+ ':'); double a = Math.random()*(max-min+1)+min; System.out.println(a); //Generate random int value from 200 to 400 System.out.println('Random value of type int between '+min+' to '+max+ ':'); int b = (int)(Math.random()*(max-min+1)+min); System.out.println(b); } } 

Sortie 1 :

 Random value of type double between 200 to 400: 233.88329802655377 Random value of type int between 200 to 400: 329 

Sortie 2 :

 Random value of type double between 200 to 400: 254.8419979875385 Random value of type int between 200 to 400: 284 

Utiliser la classe aléatoire

Une autre façon de générer un nombre aléatoire consiste à utiliser le Java aléatoire classe de lajava.utilemballer. Il génère un flux de nombres pseudo-aléatoires. Nous pouvons générer un nombre aléatoire de n'importe quel type de données, tel que entier, flottant, double, booléen, long. Si vous envisagez d'utiliser cette classe pour générer des nombres aléatoires, suivez les étapes ci-dessous :

• Tout d'abord, importez la classejava.lang.Aléatoire.
• Créé un objet de la classe Random.
• Invoquez l’une des méthodes suivantes :
nextInt (int lié) suivantInt() suivantFloat() suivantDouble() suivantLong() suivantBooléen()

Toutes les méthodes ci-dessus renvoient la prochaine valeur pseudo-aléatoire distribuée de manière homogène (méthode correspondante) à partir de la séquence de ce générateur de nombres aléatoires. Le suivantDouble() et suivantFloat() La méthode génère une valeur aléatoire comprise entre 0,0 et 1,0.

Le nextInt (int lié) La méthode accepte une limite de paramètre (supérieure) qui doit être positive. Il génère un nombre aléatoire compris entre 0 et borné-1.

Créons un programme qui génère des nombres aléatoires à l'aide de la classe Random.

RandomNumberExample3.java

 import java.util.Random; public class RandomNumberExample3 { public static void main(String args[]) { // creating an object of Random class Random random = new Random(); // Generates random integers 0 to 49 int x = random.nextInt(50); // Generates random integers 0 to 999 int y = random.nextInt(1000); // Prints random integer values System.out.println('Randomly Generated Integers Values'); System.out.println(x); System.out.println(y); // Generates Random doubles values double a = random.nextDouble(); double b = random.nextDouble(); // Prints random double values System.out.println('Randomly Generated Double Values'); System.out.println(a); System.out.println(b); // Generates Random float values float f=random.nextFloat(); float i=random.nextFloat(); // Prints random float values System.out.println('Randomly Generated Float Values'); System.out.println(f); System.out.println(i); // Generates Random Long values long p = random.nextLong(); long q = random.nextLong(); // Prints random long values System.out.println('Randomly Generated Long Values'); System.out.println(p); System.out.println(q); // Generates Random boolean values boolean m=random.nextBoolean(); boolean n=random.nextBoolean(); // Prints random boolean values System.out.println('Randomly Generated Boolean Values'); System.out.println(m); System.out.println(n); } } 

Sortir:

 Randomly Generated Integers Values 23 767 Randomly Generated Double Values 0.37823814494212016 0.998058172671956 Randomly Generated Float Values 0.87804186 0.93880254 Randomly Generated Long Values -4974823544291679198 3650240138416076693 Randomly Generated Boolean Values false true 

Utilisation de la classe ThreadLocalRandom

Le SujetLocalAléatoire la classe est définie dansjava.util.concurrentemballer. Il est initialisé avec une graine générée en interne, la même que le générateur aléatoire de la classe Math. Il ne peut pas être modifié. Nous pouvons utiliser cette classe de la manière suivante :

 ThreadLocalRandom.current().nextX(...) 

Où X est Int, Long, etc.

Remarque : Il est impossible de partager accidentellement un ThreadLocalRandom avec plusieurs threads.

Nous pouvons générer un nombre aléatoire de n'importe quel type de données, tel que entier, flottant, double, booléen, long. Si vous comptez utiliser cette classe pour générer des nombres aléatoires, suivez les étapes ci-dessous :

• Tout d’abord, importez la classe en utilisantjava.util.concurrent.ThreadLocalRandom.
• Appelez la méthode correspondante pour laquelle vous souhaitez générer des nombres de manière aléatoire.
suivantInt() suivantDouble() suivantLong() suivantFloat() suivantBooléen()

Toutes les méthodes ci-dessus remplacent la méthode correspondante de la classe Random et renvoient la valeur correspondante.

nextInt (int lié) suivantDouble(int lié) nextLong(int lié)

Les méthodes ci-dessus analysent un paramètre lié (supérieur) qui doit être positif . Il renvoie la valeur générée aléatoirement correspondante entre 0 (inclus) et la limite spécifiée (exclusive). Ça jette IllégalArgumentExcetion si la borne est négative.

nextInt (int origine, int lié) nextDouble (int origine, int lié) nextLong (int origine, int lié)

Les méthodes ci-dessus analysent deux paramètres origine et lié . L'origine précise le moindre valeur renvoyé et la limite spécifie le limite supérieure . Il renvoie la valeur générée aléatoirement correspondante entre l'origine spécifiée (incluse) et la limite (exclusive). Aussi, jette IllégalArgumentExcetion si l'origine est supérieure ou égale à la limite.

Créons un programme qui génère des nombres aléatoires en utilisant le Classe ThreadLocalRandom .

RandomNumberExample4.java

 import java.util.concurrent.ThreadLocalRandom; public class RandomNumberExample4 { public static void main(String args[]) { // Generate random integers between 0 to 999 int a = ThreadLocalRandom.current().nextInt(); int b = ThreadLocalRandom.current().nextInt(); // Print random integer values System.out.println('Randomly Generated Integer Values:'); System.out.println(a); System.out.println(b); // Generate Random double values double c = ThreadLocalRandom.current().nextDouble(); double d = ThreadLocalRandom.current().nextDouble(); // Print random doubles System.out.println('Randomly Generated Double Values:'); System.out.println(c); System.out.println(d); // Generate random boolean values boolean e = ThreadLocalRandom.current().nextBoolean(); boolean f = ThreadLocalRandom.current().nextBoolean(); // Print random Booleans System.out.println('Randomly Generated Boolean Values:'); System.out.println(e); System.out.println(f); } } 

Sortie 1 :

 Randomly Generated Integer Values: 348534891 -1887936727 Randomly Generated Double Values: 0.15644440033119833 0.5242730752133399 Randomly Generated Boolean Values: true true 

Sortie 2 :

 Output 2: Randomly Generated Integer Values: 402755574 295398333 Randomly Generated Double Values: 0.4856461791062565 0.5148677091077654 Randomly Generated Boolean Values: false true 

De même, nous pouvons utiliser d’autres méthodes de ThreadLocalRandomclass .

Génération de nombres aléatoires en Java 8

Dans Java 8, une nouvelle méthode ints() a été ajoutée au Classe aléatoire . Il faut importer lejava.util.Randomavant d'utiliser la méthode.

entiers() :

Les valeurs int pseudo-aléatoires sont générées de la même manière que l'appel de la méthode nextInt(). Il renvoie un flux illimité de valeurs int pseudo-aléatoires.

entiers (long streamSize):

La méthode analyse un paramètre taille du flux de type long. Il précise le nombre de valeurs à générer. Les valeurs int pseudo-aléatoires sont générées de la même manière que l'appel de la méthode nextInt(). Il renvoie également un flux de valeurs int générées aléatoirement. Ça jette Exception d'argument illégal si la taille du flux est inférieure à zéro.

ints (long streamSize, int randomNumberOrigin, int randomNumberBound) :

Paramètres:

taille du flux :Nombre de valeurs à générer.randomNumberOrigin :Origine de chaque valeur aléatoireRandomNumberBound :Limite de chaque valeur aléatoire

Il renvoie un flux de valeurs int pseudo-aléatoires avec l'origine et la limite spécifiées. Ça jette Exception d'argument illégal si:

• taille_tram<0< li>
• origine > = lié

 ints(int randomNumberOrigin, int randomNumberBound): 

Paramètres:

Il renvoie un flux illimité de valeurs int pseudo-aléatoires avec l'origine et la limite spécifiées. Ça jette Exception d'argument illégal si l'origine est supérieure ou égale à la limite.

De même, nous pouvons également générer le flux de types longs et doubles en utilisant le longs() et double() méthode, respectivement.

Créons un programme qui génère un flux d'entiers en utilisant le entiers() méthode de la classe Random.

10 sur 50,00

RandomNumberExample5.java

 import java.util.Random; public class RandomNumberExample5 { public static void main(String[] args) { randomInts(5); randomInts(9, 50, 90); //getStreamOfRandomInts(30, 50); } //method that generates a stream of integers having size 5 public static void randomInts(int num) { Random random = new Random(); random.ints(num).forEach(System.out::println); } //method that generates a stream of 9 integers between 50 to 90 public static void randomInts(int num, int origin, int bound) { Random random1 = new Random(); random1.ints(num, origin, bound).forEach(System.out::println); } } 

Sortie 1 :

 727900357 -1073118456 306279822 370327182 1366265119 65 75 75 88 76 75 56 86 85 

Sortie 2 :

 -1338107947 -1698771421 594232770 -1224937976 -1625069815 56 69 67 87 64 52 72 75 76