En Java programació, sovint ho demanàvem generar nombres aleatoris mentre desenvolupem aplicacions. Moltes aplicacions tenen la funció genera números aleatòriament , com ara per verificar l'usuari moltes aplicacions utilitzen el OTP . El millor exemple de nombres aleatoris són els daus. Perquè quan el llencem, obtenim un nombre aleatori entre 1 i 6.

En aquesta secció, aprendrem què és a nombre aleatori i com generar números aleatoris Java .

Nombre aleatori

Els nombres aleatoris són els nombres que utilitzen un gran conjunt de nombres i selecciona un nombre mitjançant l'algorisme matemàtic. Compleix les dues condicions següents:

• Els valors generats es distribueixen uniformement en un interval definit.
• És impossible endevinar el valor futur a partir dels valors actuals i passats.

Generació de nombres aleatoris en Java

A Java, hi ha tres vies per generar números aleatoris mitjançant el mètode i les classes.

• Utilitzant el aleatori () Mètode
• Utilitzant el aleatòria Classe
• Utilitzant el ThreadLocalRandom Classe
• Utilitzant el int() Mètode (a Java 8)

Utilitzant el mètode Math.random().

El Java Matemàtiques La classe té molts mètodes per a diferents operacions matemàtiques. Un d'ells és el aleatori () mètode. És un estàtica mètode de la classe de matemàtiques. El podem invocar directament. Només genera doble escriviu un nombre aleatori superior o igual a 0,0 i inferior a 1,0 . Abans d'utilitzar el mètode aleatori (), hem d'importar el fitxerjava.lang.Mathclasse.

Sintaxi:

 public static double random() 

No accepta cap paràmetre. Retorna un doble pseudoaleatori superior o igual a 0,0 i inferior a 1,0.

Creem un programa que generi nombres aleatoris mitjançant el mètode aleatori ().

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()); } } 

Sortida:

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

Recordeu: Cada vegada obtenim una sortida diferent quan executem el programa. La vostra sortida pot ser diferent de la que es mostra a dalt.

També podem utilitzar la fórmula següent si volem generar un nombre aleatori entre un interval especificat.

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

A la fórmula anterior, el valor mínim és inclòs mentre que el valor màxim és exclusiu.

Creem un programa que generi nombres aleatoris entre 200 i 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); } } 

Sortida 1:

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

Sortida 2:

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

Ús de la classe aleatòria

Una altra manera de generar un nombre aleatori és utilitzar el Java aleatòria classe deljava.utilpaquet. Genera un flux de nombres pseudoaleatoris. Podem generar un nombre aleatori de qualsevol tipus de dades, com ara enter, float, double, boolean, long. Si utilitzeu aquesta classe per generar números aleatoris, seguiu els passos que s'indiquen a continuació:

char a int java

• Primer, importa la classejava.lang.Random.
• Crea un objecte de la classe Random.
• Invoqueu qualsevol dels mètodes següents:
nextInt(int bound) nextInt() nextFloat() següentDoble() següentLlarg() nextBoolean()

Tots els mètodes anteriors retornen el següent valor pseudoaleatori, distribuït de manera homogènia (mètode corresponent) de la seqüència d'aquest generador de números aleatoris. El següentDoble() i nextFloat() El mètode genera un valor aleatori entre 0,0 i 1,0.

El nextInt(int bound) El mètode accepta un límit de paràmetre (superior) que ha de ser positiu. Genera un nombre aleatori en el rang de 0 a bound-1.

Creem un programa que generi nombres aleatoris utilitzant 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); } } 

Sortida:

 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 

Utilitzant la classe ThreadLocalRandom

El ThreadLocalRandom la classe es defineix ajava.util.concurrentpaquet. S'inicia amb una llavor generada internament, igual que el generador aleatori de la classe de matemàtiques. No es pot modificar. Podem utilitzar aquesta classe de la següent manera:

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

On X és Int, Long, etc.

Nota: és impossible compartir un ThreadLocalRandom amb diversos fils accidentalment.

Podem generar un nombre aleatori de qualsevol tipus de dades, com ara enter, float, double, boolean, long. Si utilitzeu aquesta classe per generar números aleatoris, seguiu els passos que s'indiquen a continuació:

• Primer, importeu la classe utilitzantjava.util.concurrent.ThreadLocalRandom.
• Invoqueu el mètode corresponent per al qual voleu generar números aleatòriament.
nextInt() següentDoble() següentLlarg() nextFloat() nextBoolean()

Tots els mètodes anteriors anul·len el mètode corresponent de la classe Random i retornen el valor corresponent.

nextInt(int bound) nextDouble (inte lligat) nextLong(int bound)

Els mètodes anteriors analitzen un paràmetre lligat (superior) això ha de ser positiu . Retorna el valor generat aleatòriament corresponent entre 0 (inclòs) i el límit especificat (exclusiu). Es tira IllegalArgumentExcetion si la cota és negativa.

nextInt(int origin, int bound) nextDouble (origen int, lligat int) nextLong (origen int, lligat int)

Els mètodes anteriors analitzen dos paràmetres origen i lligat . L'origen especifica el menys valor retornat i el límit especifica el límit superior . Retorna el valor generat aleatòriament corresponent entre l'origen especificat (inclòs) i l'enllaç (exclusiu). També, llançaments IllegalArgumentExcetion si l'origen és superior o igual a l'acotat.

Creem un programa que generi nombres aleatoris utilitzant el 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); } } 

Sortida 1:

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

Sortida 2:

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

De la mateixa manera, podem utilitzar altres mètodes de ThreadLocalRandomclass .

Generació de números aleatoris a Java 8

A Java 8, s'ha afegit un nou mètode ints() al fitxer Classe aleatòria . Hem d'importar eljava.util.Randomabans d'utilitzar el mètode.

int():

Els valors int pseudoaleatoris van generar el mateix que cridar al mètode nextInt(). Retorna un flux il·limitat de valors int pseudoaleatoris.

ints(mida del flux llarg):

El mètode analitza un paràmetre streamSize de tipus llarg. Especifica el nombre de valors a generar. Els valors int pseudoaleatoris van generar el mateix que cridar al mètode nextInt(). També retorna un flux de valors int generats aleatòriament. Es tira IllegalArgumentException si la mida del flux és inferior a zero.

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

Paràmetres:

streamSize:Nombre de valors a generar.randomNumberOrigin:Origen de cada valor aleatorirandomNumberBound:Lligat de cada valor aleatori

Retorna un flux de valors int pseudoaleatoris amb l'origen i l'enllaç especificats. Es tira IllegalArgumentException si:

• stramSize<0< li>
• origen > = lligat

 ints(int randomNumberOrigin, int randomNumberBound): 

Paràmetres:

Retorna un flux il·limitat de valors int pseudoaleatoris amb l'origen i l'enllaç especificats. Es tira IllegalArgumentException si l'origen és superior o igual a l'acotat.

De la mateixa manera, també podem generar el flux de tipus llargs i dobles mitjançant l' anhela () i dobles () mètode, respectivament.

Anem a crear un programa que generi un flux d'enters amb l' int() mètode de la classe aleatòria.

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); } } 

Sortida 1:

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

Sortida 2:

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