I Java programmering, som vi ofta krävde generera slumpmässiga tal medan vi utvecklar applikationer. Många applikationer har funktionen att generera tal slumpmässigt , till exempel för att verifiera användaren många applikationer använder OTP . Det bästa exemplet på slumptal är tärningar. För när vi kastar det får vi ett slumptal mellan 1 och 6.
I det här avsnittet kommer vi att lära oss vad som är en slumpmässigt nummer och hur man genererar slumptal i Java .
Slumpmässigt nummer
Slumptal är siffror som använder en stor uppsättning siffror och väljer ett tal med hjälp av den matematiska algoritmen. Den uppfyller följande två villkor:
- De genererade värdena är likformigt fördelade över ett bestämt intervall.
- Det är omöjligt att gissa det framtida värdet baserat på nuvarande och tidigare värden.
Genererar slumptal i Java
I Java finns det tre sätt att generera slumptal med metoden och klasserna.
- Använda slumpmässig() Metod
- Använda slumpmässig Klass
- Använda ThreadLocalRandom Klass
- Använda ints() Metod (i Java 8)
Använda Math.random()-metoden
Java Matematik klass har många metoder för olika matematiska operationer. En av dem är slumpmässig() metod. Det är en statisk matematikklassens metod. Vi kan åberopa det direkt. Det genererar bara dubbel skriv slumptal större än eller lika med 0,0 och mindre än 1,0 . Innan vi använder metoden random() måste vi importerajava.lang.Mathklass.
Syntax:
public static double random()
Den accepterar inte någon parameter. Den returnerar en pseudoslumpmässig dubbel som är större än eller lika med 0,0 och mindre än 1,0.
k närmaste granne
Låt oss skapa ett program som genererar slumptal med metoden 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()); } } Produktion:
1st Random Number: 0.17434160924512265 2nd Random Number: 0.4297410090709448 3rd Random Number: 0.4828656381344487 4th Random Number: 0.13267917059488898
Kom ihåg: Varje gång får vi en annan utdata när vi kör programmet. Din utdata kan skilja sig från utdata som visas ovan.
Vi kan också använda följande formel om vi vill generera ett slumptal mellan ett specificerat område.
Math.random() * (max - min + 1) + min
I formeln ovan är minvärdet inklusive medan maxvärdet är exklusivt.
Låt oss skapa ett program som genererar slumptal mellan 200 och 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); } } Utgång 1:
Random value of type double between 200 to 400: 233.88329802655377 Random value of type int between 200 to 400: 329
Utgång 2:
alfabetet till nummer
Random value of type double between 200 to 400: 254.8419979875385 Random value of type int between 200 to 400: 284
Använder Random Class
Ett annat sätt att generera ett slumptal är att använda Java slumpmässig klass avjava.utilpaket. Det genererar en ström av pseudoslumptal. Vi kan generera ett slumptal av vilken datatyp som helst, som heltal, float, double, boolesk, long. Om du ska använda den här klassen för att generera slumpmässiga tal, följ stegen nedan:
- Importera först klassenjava.lang.Random.
- Skapa en objekt av klassen Random.
- Åberopa någon av följande metoder:
Alla ovanstående metoder returnerar nästa pseudoslumpmässiga, homogent fördelade värde (motsvarande metod) från denna slumptalsgenerators sekvens. De nextDouble() och nextFloat() metoden genererar slumpmässiga värden mellan 0,0 och 1,0.
De nästaInt(int bundet) metod accepterar en parametergräns (övre) som måste vara positiv. Den genererar ett slumptal i intervallet 0 till bound-1.
Låt oss skapa ett program som genererar slumptal med klassen Random.
kali linux kommandon
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); } } Produktion:
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
Använda ThreadLocalRandom Class
De ThreadLocalRandom klass definieras ijava.util.samtidigpaket. Den initieras med ett internt genererat frö, samma som slumpgeneratorn i Math-klassen. Det går inte att ändra. Vi kan använda den här klassen på följande sätt:
ThreadLocalRandom.current().nextX(...)
Där X är Int, Long, etc.
Obs: Det är omöjligt att dela en ThreadLocalRandom med flera trådar av misstag.
Vi kan generera ett slumptal av vilken datatyp som helst, som heltal, float, double, boolesk, long. Om du ska använda den här klassen för att generera slumpmässiga tal, följ stegen nedan:
- Importera först klassen genom att användajava.util.concurrent.ThreadLocalRandom.
- Anropa motsvarande metod för vilken du vill generera tal slumpmässigt.
Alla ovanstående metoder åsidosätter motsvarande metod för klassen Random och returnerar motsvarande värde.
Ovanstående metoder analyserar en parameter bunden (övre) det måste vara positiv . Den returnerar motsvarande slumpmässigt genererade värde mellan 0 (inklusive) och den angivna gränsen (exklusiv). Det kastar IllegalArgumentExcetion om gränsen är negativ.
Ovanstående metoder analyserar två parametrar ursprung och bunden . Ursprunget anger minsta värde returneras och bunden anger övre gräns . Den returnerar motsvarande slumpmässigt genererade värde mellan det angivna ursprunget (inklusive) och bundet (exklusivt). Kastar också IllegalArgumentExcetion om ursprunget är större än eller lika med bundet.
Låt oss skapa ett program som genererar slumptal med hjälp av ThreadLocalRandom-klass .
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); } } Utgång 1:
Randomly Generated Integer Values: 348534891 -1887936727 Randomly Generated Double Values: 0.15644440033119833 0.5242730752133399 Randomly Generated Boolean Values: true true
Utgång 2:
Output 2: Randomly Generated Integer Values: 402755574 295398333 Randomly Generated Double Values: 0.4856461791062565 0.5148677091077654 Randomly Generated Boolean Values: false true
På samma sätt kan vi använda andra metoder för ThreadLocal Randomclass .
förbeställ genomgång
Generering av slumptal i Java 8
I Java 8 har en ny metod ints() lagts till i Slumpmässig klass . Vi måste importerajava.util.Randominnan du använder metoden.
ints():
De pseudoslumpmässiga int-värdena genererade samma som att anropa metoden nextInt(). Den returnerar en obegränsad ström av pseudoslumpmässiga int-värden.
ints(long streamSize):
Metoden analyserar en parameter streamSize av typen lång. Den anger antalet värden som ska genereras. De pseudoslumpmässiga int-värdena genererade samma som att anropa metoden nextInt(). Den returnerar också en ström av slumpmässigt genererade int-värden. Det kastar IllegalArgumentException om strömstorleken är mindre än noll.
ints(long streamSize, int randomNumberOrigin, int randomNumberBound):
Parametrar:
Den returnerar en ström av pseudoslumpmässiga int-värden med angivet ursprung och bunden. Det kastar IllegalArgumentException om:
- stramSize<0< li>
- ursprung > = bundet
ints(int randomNumberOrigin, int randomNumberBound):
Parametrar:
Den returnerar en obegränsad ström av pseudoslumpmässiga int-värden med angivet ursprung och bunden. Det kastar IllegalArgumentException om ursprunget är större än eller lika med bundet.
mylivecricket in för live cricket
På samma sätt kan vi också generera strömmen av långa och dubbla typer genom att använda längtar efter() och dubbel() metod.
Låt oss skapa ett program som genererar en ström av heltal med hjälp av ints() metod för klassen Random.
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); } } Utgång 1:
727900357 -1073118456 306279822 370327182 1366265119 65 75 75 88 76 75 56 86 85
Utgång 2:
-1338107947 -1698771421 594232770 -1224937976 -1625069815 56 69 67 87 64 52 72 75 76