Was ist der Zufallszahlengenerator in Java?
Zufallszahlen werden häufig zum Erstellen von Anwendungen wie Würfeln für ein Brettspiel, ein Glücksspielprogramm usw. verwendet. Normalerweise nimmt die Erzeugung von Zufallszahlen viel Zeit in Anspruch. In der Programmiersprache Java kann dies jedoch auf drei Arten erreicht werden. Sie werden im folgenden Abschnitt Zufallszahlengeneratorfunktionen in Java behandelt.
Zufallszahlengenerator-Funktionen in Java
In Java können Zufallszahlen auf drei Arten generiert werden:
- Math.random-Methode
- java.util.Random-Klasse
- ThreadLocalRandom-Klasse
1. Math.random () Methode
Die Java Math-Klasse bietet eine Reihe von Methoden zur Bearbeitung von Berechnungen wie Logarithmen, Durchschnitt, Potenzierung usw. random () ist eine der Methoden, die einen positiven Doppelwert im Bereich von 0, 0 bis 1, 0 zurückgibt, wobei 0, 0 einschließlich und 0, 0 ist 1.0 ist exklusiv. Diese Methode kann mit oder ohne Parameter verwendet werden. Wenn Parameter angegeben werden, liegt die generierte Zufallszahl innerhalb des angegebenen Parameterbereichs.
Beispiel 1
Code:
public class RandomNumber (
double num; //Declare a variable num
//Method which generates a random number
public double randnum()
(
num=Math.random();
return num;
)
// Main Method of a program
public static void main(String() args) (
//Printing a random number
System.out.println("Random Number generated inside main method: "+Math.random());
//Create an object of the class RandomNumber
RandomNumber randomobj=new RandomNumber();
//Store the return value obtained from randnum method in a variable randomval
double randomval=randomobj.randnum();
//Printing the random number stored in variable randomval
System.out.println("Random Number generated inside randomnumber method: "+randomval);
)
)
Ausgabe:
Im obigen Beispiel wird die Zufallszahl mithilfe der Math.random () -Methode auf zwei Arten generiert: Direktes Anwenden innerhalb der Hauptmethode und Aufrufen einer Methode, die Math.random () enthält, mithilfe des Objekts. Wie in der obigen Erläuterung erwähnt, werden 2 Zufallszahlen im Bereich von 0, 0 bis 1, 0 generiert.
Um eine Zufallszahl innerhalb des Parameterbereichs zu generieren, wird im Folgenden der allgemeine Ausdruck verwendet:
Math.random () * ((maxvalue - minvalue) +1) + minvalue
Beispiel # 2
Dabei ist maxvalue die obere Grenze des Bereichs und min value die untere Grenze des Bereichs. Um beispielsweise eine Zufallszahl zwischen 10 und 20 zu generieren, setzen Sie den Maximalwert auf 20 und den Minimalwert auf 10.
Code:
public class RandomNumParameters (
public double randomnum(double x, double y)//max value-y, min value-x
(
double z =(Math.random()*((yx)+1)+x); //Formula for random number generation within a range
return z;
)
public static void main(String() args)
(
RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters
double num=ran.randomnum(3.0, 10.0); //Call the Method
System.out.println("Random number generated within the range of 3 and 10: "+num );
) )
Ausgabe:
2. java.util.Random Class
Die Java.util.Random-Klasse generiert Zufallszahlen mit unterschiedlichen Datentypen wie float, long, integer, double, boolean usw. Es ist auch möglich, den Zahlenbereich als Argumente zu übergeben, damit innerhalb dieses Bereichs eine Zufallszahl generiert wird . Um diese Klasse zu verwenden, muss die Random-Klasse von java.util importiert werden (java.util.Random). Nachdem diese Klasse importiert wurde, erstellen Sie eine Instanz und rufen Sie die Methoden wie next long (), nextInt () usw. mit dieser Instanz auf.
Beispiel 1
Code:
//Java program to generate Random numbers using Random class
package Sample;
import java.util.Random; //import Random Class
public class RandomNum (
public static void main(String() args) (
Random rand=new Random(); //Create instance of Random class
double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable
System.out.println("Random Double value: "+ randomnum);
)
)
Ausgabe:
Im obigen Programm wird mit der Methode nextDouble () ein zufälliger Doppelwert erzeugt.
3. ThreadLocalRandom-Klasse
Die ThreadLocalRandom-Klasse ist ein spezieller Typ der Random-Klasse, der in Java Version 1.7 eingeführt wurde. ThreadLocalRandom.current (). NextInt () ist eine der gängigen Methoden zum Generieren von Zufallszahlen. Es wird normalerweise in Multithread-Anwendungen verwendet.
Beispiel 1
Code:
//Java Program to generate random numbers using ThreadLocalRandom Class
import java.util.concurrent.ThreadLocalRandom;
public class RandomNumThread (
public static void main(String() args) (
//print a random double
System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble());
)
)
Ausgabe:
Erzeugung von ganzen Zahlen
Zufällige Ganzzahlen können mithilfe der ThreadLocalRandom-Klasse und der Random-Klasse generiert werden. In beiden Fällen wird eine Methode nextInt () für dasselbe verwendet:
Beispiel 1
Code:
//Java program to generate Random integer numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomInteger (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
int randomnum1=rnd.nextInt(); //Random Integer value using Random Class
int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30
int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class
System.out.println("Random Integer value using Random Class: "+ randomnum1);
System.out.println("Random Integer value within the range of 30: "+ randomnum2);
System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3);
)
)
Ausgabe:
Im obigen Beispiel werden drei Zahlen vom Typ Zufällige Ganzzahl generiert, wobei eine der nextInt () -Methoden 30 als Argument hat. Beim Erzeugen einer Zufallszahl wird also 30 als Obergrenze und Null (Standarduntergrenze) als Untergrenze festgelegt.
Fließkommazahlen generieren
Ähnlich wie bei der Generierung von Ganzzahlen können Gleitkommazahlen mit der Methode nextFloat () generiert werden. Diese Methode kann sowohl in der Random-Klasse als auch in der ThreadLocalRandom-Klasse verwendet werden:
Beispiel 1
Code:
//Java program to generate Random Float numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomFloat (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
float randomnum1=rnd.nextFloat(); //Random Float value using Random Class
float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class
System.out.println("Random float value using Random Class: "+ randomnum1);
System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2);
)
)
Ausgabe:
Fazit
Java enthält eine Vielzahl von Funktionen, die in Programmen verwendet werden können. Dies hilft bei der Reduzierung der Verarbeitungszeit und Codezeilen. Die Zufallszahlengenerierung ist eine Aufgabe, bei der wir einige dieser Funktionen verwenden können. Dieses Dokument beschreibt die verschiedenen Methoden, um dies zu erreichen.
Empfohlene Artikel
Dies ist eine Anleitung zum Zufallszahlengenerator in Java. Hier diskutieren wir Funktionen in Java mit Beispielen und zwei verschiedenen Generatoren. Sie können auch unsere anderen verwandten Artikel durchgehen, um mehr zu erfahren -
- Zufallszahlengenerator in Python
- Zufallszahlengenerator in C
- Zufallszahlengenerator in R
- Rekursion in Java
- Zufallszahlengenerator in Matlab
- Zufallszahlengenerator in C #
- Arrays in der Java-Programmierung
- Zufallszahlengenerator in JavaScript
- Zufallszahlengenerator in PHP