Ban ben Jáva programozás, gyakran megkívántuk véletlen számokat generál miközben alkalmazásokat fejlesztünk. Sok alkalmazás rendelkezik ezzel a funkcióval véletlenszerűen generál számokat , mint például a felhasználó ellenőrzésére, sok alkalmazás használja a OTP . A véletlen számok legjobb példája a kocka. Mert amikor feldobjuk, 1 és 6 közötti véletlenszámot kapunk.

Ebben a részben megtudjuk, mi az a véletlen szám és hogyan lehet véletlen számokat generálni Jáva .

Véletlen szám

A véletlen számok olyan számok, amelyek nagy számkészletet használnak, és a matematikai algoritmus segítségével kiválasztanak egy számot. Az alábbi két feltételnek eleget tesz:

• A generált értékek egyenletesen oszlanak el egy meghatározott intervallumon belül.
• A jelenlegi és múltbeli értékek alapján lehetetlen megtippelni a jövőbeli értéket.

Véletlen szám generálása Java nyelven

A Java-ban háromféleképpen lehet véletlen számokat generálni a metódus és az osztályok használatával.

• Használni a véletlen() Módszer
• Használni a véletlen Osztály
• Használni a ThreadLocalRandom Osztály
• Használni a ints() Módszer (Java 8-ban)

A Math.random() módszer használata

A Java Math osztálynak számos módszere van a különböző matematikai műveletekhez. Ezek egyike a véletlen() módszer. Ez egy statikus a matematika óra módszere. Közvetlenül hívhatjuk. Csak generál kettős írja be a véletlen számot nagyobb vagy egyenlő, mint 0,0 és kevesebb, mint 1,0 . A random() metódus használata előtt importálnunk kell ajava.lang.Mathosztály.

Szintaxis:

 public static double random() 

Nem fogad el semmilyen paramétert. Egy pszeudovéletlen duplát ad vissza, amely nagyobb vagy egyenlő 0,0-nál és kisebb, mint 1,0.

Készítsünk programot, amely véletlen számokat generál a random() metódussal.

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

Kimenet:

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

Emlékezik: Minden alkalommal más kimenetet kapunk, amikor végrehajtjuk a programot. A kimenet eltérhet a fent látható kimenettől.

számozza meg az ábécét

A következő képletet is használhatjuk, ha véletlen számot szeretnénk generálni egy megadott tartomány között.

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

A fenti képletben a min érték belefoglaló, míg a max érték kizáró.

Készítsünk egy programot, amely 200 és 400 közötti véletlen számokat generál.

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

1. kimenet:

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

2. kimenet:

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

A véletlenszerű osztály használata

Egy másik módja a véletlen szám generálására a Jáva véletlen osztály ajava.utilcsomag. Álvéletlen számok folyamát generálja. Bármilyen adattípusból véletlenszámot generálhatunk, például egész, float, double, Boolean, long. Ha ezt az osztályt véletlen számok generálására használja, kövesse az alábbi lépéseket:

c# lista

• Először importálja az osztálytjava.lang.Véletlenszerű.
• Hozzon létre egy tárgy a Random osztályból.
• Hívja elő a következő módszerek bármelyikét:
nextInt(int kötött) nextInt() nextFloat() következőDouble() nextLong() nextBoolean()

A fenti metódusok mindegyike a következő pszeudovéletlen, homogén eloszlású értéket (megfelelő módszert) adja vissza ebből a véletlenszám-generátor sorozatából. A következőDouble() és nextFloat() módszer véletlenszerű értéket generál 0,0 és 1,0 között.

A nextInt(int kötött) metódus elfogad egy paraméterkorlátot (felső), amelynek pozitívnak kell lennie. Véletlen számot generál a 0-tól korlátos-1-ig terjedő tartományban.

Készítsünk egy programot, amely véletlen számokat generál a Random osztály segítségével.

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

Kimenet:

 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 

A ThreadLocalRandom osztály használata

A ThreadLocalRandom osztályban van meghatározvajava.util.concurrentcsomag. Egy belsőleg generált maggal van inicializálva, ugyanaz, mint a Math osztály véletlen generátora. Nem módosítható. Ezt az osztályt a következő módon használhatjuk:

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

Ahol X az Int, Long stb.

Megjegyzés: Lehetetlen véletlenül megosztani egy ThreadLocalRandom-ot több szállal.

Bármilyen adattípusból véletlenszámot generálhatunk, például egész, float, double, Boolean, long. Ha ezt az osztályt véletlen számok generálására használja, kövesse az alábbi lépéseket:

• Először importálja az osztályt a használatávaljava.util.concurrent.ThreadLocalRandom.
• Hívja meg a megfelelő metódust, amelyhez véletlenszerűen számokat szeretne generálni.
nextInt() következőDouble() nextLong() nextFloat() nextBoolean()

A fenti metódusok mindegyike felülírja a Random osztály megfelelő metódusát, és a megfelelő értéket adja vissza.

tömblista rendezés

nextInt(int kötött) nextDouble (int kötött) nextLong (int kötött)

A fenti módszerek egy paramétert elemeznek összekötött (felső) ennek kell lennie pozitív . A megfelelő véletlenszerűen generált értéket adja vissza 0 (beleértve) és a megadott korlát (kizárólag) között. Ez dob IllegalArgumentExcetion ha a korlát negatív.

nextInt(int eredet, int kötött) következőDouble(int eredet, int kötött) nextLong(int origin, int bound)

A fenti módszerek két paramétert elemeznek eredet és összekötött . Az eredet megadja a legkisebb értéket vissza, és a kötött meghatározza a felső határ . A megfelelő véletlenszerűen generált értéket adja vissza a megadott eredet (beleértve) és kötött (kizárólag) között. Továbbá dobások IllegalArgumentExcetion ha az origó nagyobb vagy egyenlő a kötöttnél.

Készítsünk egy programot, amely véletlen számokat generál a ThreadLocalVéletlenszerű osztály .

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

1. kimenet:

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

2. kimenet:

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

Hasonlóképpen használhatunk más módszereket is ThreadLocalRandomclass .

Véletlenszám-generálás Java 8-ban

A Java 8-ban egy új ints() metódus került be a Véletlen osztály . Importálnunk kell ajava.util.Véletlenszerűa módszer alkalmazása előtt.

ints():

A pszeudovéletlen int értékek ugyanazt generálták, mint a nextInt() metódus meghívásakor. A pszeudovéletlen int értékek korlátlan folyamát adja vissza.

ints (hosszú streamSize):

A metódus elemzi egy paramétert streamSize típusú hosszú. Meghatározza a generálandó értékek számát. A pszeudovéletlen int értékek ugyanazt generálták, mint a nextInt() metódus meghívásakor. Véletlenszerűen generált int értékeket is visszaad. Ez dob IllegalArgumentException ha az adatfolyam mérete kisebb, mint nulla.

ints (hosszú folyamméret, int véletlenszám eredet, int véletlenszám határ):

Paraméterek:

folyam mérete:A létrehozandó értékek száma.randomNumberOrigin:Minden véletlen érték eredeterandomNumberBound:Minden véletlen érték korlátja

Pseudorandom int értékeket ad vissza a megadott eredet és kötött értékkel. Ez dob IllegalArgumentException ha:

• stramSize<0< li>
• eredet > = kötött

 ints(int randomNumberOrigin, int randomNumberBound): 

Paraméterek:

A pszeudovéletlen int értékek korlátlan számú adatfolyamát adja vissza a megadott eredettel és kötöttséggel. Ez dob IllegalArgumentException ha az origó nagyobb vagy egyenlő a kötöttnél.

hashmap java

Hasonlóképpen a long és a double típusú folyamot is generálhatjuk a hosszú () és kettős() módszerrel, ill.

Hozzunk létre egy programot, amely egész számok folyamát állítja elő a ints() a Random osztály metódusa.

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

1. kimenet:

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

2. kimenet:

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