In Java Programmierung, das mussten wir oft tun Zufallszahlen generieren während wir Anwendungen entwickeln. Viele Anwendungen verfügen über diese Funktion Zahlen zufällig generieren , wie zum Beispiel, um den Benutzer zu überprüfen, den viele Anwendungen verwenden OTP . Das beste Beispiel für Zufallszahlen sind Würfel. Denn wenn wir es werfen, erhalten wir eine Zufallszahl zwischen 1 und 6.
In diesem Abschnitt erfahren Sie, was ein ist Zufallszahl Und wie man Zufallszahlen generiert Java .
Java-Karten
Zufallszahl
Zufallszahlen sind Zahlen, die eine große Menge von Zahlen verwenden und mithilfe des mathematischen Algorithmus eine Zahl auswählen. Es erfüllt die folgenden zwei Bedingungen:
- Die generierten Werte sind gleichmäßig über ein bestimmtes Intervall verteilt.
- Es ist unmöglich, den zukünftigen Wert anhand aktueller und vergangener Werte abzuschätzen.
Generieren einer Zufallszahl in Java
In Java gibt es drei Möglichkeiten, Zufallszahlen mithilfe von Methoden und Klassen zu generieren.
- Verwendung der zufällig() Methode
- Verwendung der zufällig Klasse
- Verwendung der ThreadLocalRandom Klasse
- Verwendung der ints() Methode (in Java 8)
Verwenden der Math.random()-Methode
Das Java Mathematik Die Klasse verfügt über viele Methoden für verschiedene mathematische Operationen. Einer davon ist der zufällig() Methode. es ist ein statisch Methode der Math-Klasse. Wir können es direkt aufrufen. Es generiert nur doppelt Geben Sie eine Zufallszahl ein größer oder gleich 0,0 Und kleiner als 1,0 . Bevor wir die random()-Methode verwenden, müssen wir die importierenjava.lang.MathKlasse.
Syntax:
public static double random()
Es werden keine Parameter akzeptiert. Es wird ein pseudozufälliges Double zurückgegeben, das größer oder gleich 0,0 und kleiner als 1,0 ist.
Lassen Sie uns ein Programm erstellen, das mithilfe der Methode random() Zufallszahlen generiert.
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()); } } Ausgabe:
1st Random Number: 0.17434160924512265 2nd Random Number: 0.4297410090709448 3rd Random Number: 0.4828656381344487 4th Random Number: 0.13267917059488898
Erinnern: Jedes Mal erhalten wir eine andere Ausgabe, wenn wir das Programm ausführen. Ihre Ausgabe kann von der oben gezeigten Ausgabe abweichen.
Wir können auch die folgende Formel verwenden, wenn wir eine Zufallszahl innerhalb eines bestimmten Bereichs generieren möchten.
Math.random() * (max - min + 1) + min
In der obigen Formel ist der Mindestwert inklusive, während der Höchstwert exklusiv ist.
Lassen Sie uns ein Programm erstellen, das Zufallszahlen zwischen 200 und 400 generiert.
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); } } Ausgabe 1:
Random value of type double between 200 to 400: 233.88329802655377 Random value of type int between 200 to 400: 329
Ausgabe 2:
Random value of type double between 200 to 400: 254.8419979875385 Random value of type int between 200 to 400: 284
Verwenden der Zufallsklasse
Eine andere Möglichkeit, eine Zufallszahl zu generieren, ist die Verwendung von Java zufällig Klasse desjava.utilPaket. Es erzeugt einen Strom von Pseudozufallszahlen. Wir können eine Zufallszahl eines beliebigen Datentyps generieren, z. B. Integer, Float, Double, Boolean, Long. Wenn Sie diese Klasse zum Generieren von Zufallszahlen verwenden möchten, führen Sie die folgenden Schritte aus:
- Importieren Sie zunächst die Klassejava.lang.Random.
- Erstelle ein Objekt der Random-Klasse.
- Rufen Sie eine der folgenden Methoden auf:
Alle oben genannten Methoden geben den nächsten pseudozufälligen, homogen verteilten Wert (entsprechende Methode) aus der Sequenz dieses Zufallszahlengenerators zurück. Der nextDouble() Und nextFloat() Die Methode generiert einen Zufallswert zwischen 0,0 und 1,0.
Der nextInt(int gebunden) Die Methode akzeptiert eine Parametergrenze (oben), die positiv sein muss. Es generiert eine Zufallszahl im Bereich von 0 bis Bound-1.
Lassen Sie uns ein Programm erstellen, das mithilfe der Random-Klasse Zufallszahlen generiert.
Volladdierer-Wahrheitstabelle
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); } } Ausgabe:
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
Verwenden der ThreadLocalRandom-Klasse
Der ThreadLocalRandom Klasse ist in definiertjava.util.concurrentPaket. Es wird mit einem intern generierten Startwert initialisiert, genau wie der Zufallsgenerator der Math-Klasse. Es kann nicht geändert werden. Wir können diese Klasse auf folgende Weise verwenden:
ThreadLocalRandom.current().nextX(...)
Wobei X Int, Long usw. ist.
Hinweis: Es ist unmöglich, ein ThreadLocalRandom versehentlich mit mehreren Threads zu teilen.
Wir können eine Zufallszahl eines beliebigen Datentyps generieren, z. B. Integer, Float, Double, Boolean, Long. Wenn Sie diese Klasse zum Generieren von Zufallszahlen verwenden möchten, führen Sie die folgenden Schritte aus:
- Importieren Sie zunächst die Klasse mithilfe vonjava.util.concurrent.ThreadLocalRandom.
- Rufen Sie die entsprechende Methode auf, für die Sie zufällig Zahlen generieren möchten.
Alle oben genannten Methoden überschreiben die entsprechende Methode der Random-Klasse und geben den entsprechenden Wert zurück.
Die oben genannten Methoden analysieren einen Parameter gebunden (oben) das muss sein positiv . Es gibt den entsprechenden zufällig generierten Wert zwischen 0 (einschließlich) und der angegebenen Grenze (exklusiv) zurück. Es wirft IllegalArgumentExcetion wenn die Grenze negativ ist.
Die oben genannten Methoden analysieren zwei Parameter Herkunft Und gebunden . Der Ursprung gibt den an geringsten Wert zurückgegeben und die Grenze gibt die an obere Grenze . Es gibt den entsprechenden zufällig generierten Wert zwischen dem angegebenen Ursprung (inklusive) und der Grenze (exklusiv) zurück. Auch Würfe IllegalArgumentExcetion wenn der Ursprung größer oder gleich der Grenze ist.
Lassen Sie uns ein Programm erstellen, das mithilfe von Zufallszahlen generiert ThreadLocalRandom-Klasse .
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); } } Ausgabe 1:
Randomly Generated Integer Values: 348534891 -1887936727 Randomly Generated Double Values: 0.15644440033119833 0.5242730752133399 Randomly Generated Boolean Values: true true
Ausgabe 2:
Output 2: Randomly Generated Integer Values: 402755574 295398333 Randomly Generated Double Values: 0.4856461791062565 0.5148677091077654 Randomly Generated Boolean Values: false true
Ebenso können wir andere Methoden verwenden ThreadLocalRandomclass .
Zufallszahlengenerierung in Java 8
In Java 8 wurde eine neue Methode ints() hinzugefügt Zufällige Klasse . Wir müssen das importierenjava.util.Randombevor Sie die Methode anwenden.
ints():
if und else in Bash
Die pseudozufälligen int-Werte werden auf die gleiche Weise generiert wie beim Aufruf der nextInt()-Methode. Es gibt einen unbegrenzten Strom pseudozufälliger int-Werte zurück.
ints(long streamSize):
Die Methode analysiert einen Parameter streamSize vom Typ lang. Es gibt die Anzahl der zu generierenden Werte an. Die pseudozufälligen int-Werte werden auf die gleiche Weise generiert wie beim Aufruf der nextInt()-Methode. Außerdem wird ein Strom zufällig generierter int-Werte zurückgegeben. Es wirft IllegalArgumentException wenn die Streamgröße kleiner als Null ist.
ints(long streamSize, int randomNumberOrigin, int randomNumberBound):
Parameter:
Es gibt einen Strom pseudozufälliger int-Werte mit dem angegebenen Ursprung und der angegebenen Grenze zurück. Es wirft IllegalArgumentException Wenn:
- stramSize<0< li>
- Ursprung > = gebunden
ints(int randomNumberOrigin, int randomNumberBound):
Parameter:
Es gibt einen unbegrenzten Strom pseudozufälliger int-Werte mit dem angegebenen Ursprung und der angegebenen Grenze zurück. Es wirft IllegalArgumentException wenn der Ursprung größer oder gleich der Grenze ist.
In ähnlicher Weise können wir auch den Stream von Long- und Double-Typen generieren, indem wir verwenden longs() Und Doppel() Methode bzw.
Lassen Sie uns ein Programm erstellen, das mithilfe von einen Strom von Ganzzahlen generiert ints() Methode der Random-Klasse.
RandomNumberExample5.java
Java math.random
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); } } Ausgabe 1:
727900357 -1073118456 306279822 370327182 1366265119 65 75 75 88 76 75 56 86 85
Ausgabe 2:
-1338107947 -1698771421 594232770 -1224937976 -1625069815 56 69 67 87 64 52 72 75 76