Zufallszahlengenerator in Java

Zufallszahlen werden häufig bei der Erstellung von Anwendungen wie Würfeln für ein Brettspiel, einem Glücksspielprogramm usw. verwendet. Normalerweise nimmt die Generierung 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.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Zufallszahlengeneratorfunktionen in Java

In Java können Zufallszahlen auf drei Arten generiert werden:

• Math.random-Methode
• java.util.Random class
• ThreadLocalRandom Klasse

1. Math.random() Methode

Die Java Math-Klasse bietet eine Reihe von Methoden für die Arbeit an Berechnungen wie Logarithmen, Durchschnitt, Potenzierung usw. random() ist eine der Methoden unter ihnen, die einen positiven Double-Wert im Bereich von 0,0 und 1,0 zurückgibt, wobei 0,0 ist inklusive und 1.0 ist exklusiv. Diese Methode kann mit oder ohne Verwendung von Parametern 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 eine Zufallszahl mithilfe der Math.random()-Methode auf zwei Arten generiert: Direkte Anwendung innerhalb der Hauptmethode und Aufrufen einer Methode, die Math.random() mithilfe des Objekts enthält.  Wie in der obigen Erklärung erwähnt, können wir sehen, dass zwei Zufallszahlen im Bereich von 0,0 und 1,0 generiert werden.

Um eine Zufallszahl innerhalb des Parameterbereichs zu generieren, wird unten der allgemeine Ausdruck verwendet:

Math.random()*  (( maxvalue – minvalue ) +1 ) + minvalue

Beispiel #2

Wobei der Maximalwert die Obergrenze des Bereichs und der Minimalwert die Untergrenze des Bereichs ist. Um beispielsweise eine Zufallszahl zwischen 10 und 20 zu generieren, legen Sie den Maximalwert auf 20 und den Minimalwert auf 10 fest.

Code:

public class RandomNumParameters {
public double randomnum(double x,double y)//max value-y, min value-x
{
double z =(Math.random()*((y-x)+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 Klasse Java.util.random generiert Zufallszahlen verschiedener Datentypen wie Float, Long, Integer, Double, Boolean usw. Es ist auch möglich, den Zahlenbereich als Argumente zu übergeben, um eine Zufallszahl innerhalb dieses Bereichs zu generieren . Um diese Klasse verwenden zu können, muss die Random-Klasse von java.util importiert werden (java.util.Random). Sobald diese Klasse importiert ist, erstellen Sie eine Instanz und rufen Sie die Methoden wie next long(), nextInt() usw. mit dieser Instanz auf.

Beispiel

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 Double-Wert generiert.

3. ThreadLocalRandom-Klasse

Die ThreadLocalRandom-Klasse ist ein spezieller Typ der Random-Klasse, der in Java Version 1.7 eingeführt wird. ThreadLocalRandom.current().nextInt() ist eine der häufigsten Methoden, die zum Generieren von Zufallszahlen verwendet werden. Es wird normalerweise in Multithread-Anwendungen verwendet.

Beispiel

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:

Generierung von Ganzzahlen

Zufällige Ganzzahlen können mit der ThreadLocalRandom-Klasse und der Random-Klasse generiert werden. In beiden Fällen wird eine Methode nextInt() für dasselbe verwendet:

Beispiel

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 Generieren einer Zufallszahl wird also 30 als Obergrenze und Null (Standarduntergrenze) als Untergrenze festgelegt.

Gleitkommazahlen generieren

Ähnlich wie bei der Generierung von Ganzzahlen können Gleitkommazahlen mit der Methode nextFloat() generiert werden. Diese Methode kann sowohl in der Random Class als auch in der ThreadLocalRandom Class:

Beispiel

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 – Zufallszahlengenerator in Java

Java enthält eine Fülle von Funktionen, die in Programmen verwendet werden können. Dies trägt dazu bei, die Verarbeitungszeit und Codezeilen zu reduzieren. Die Zufallszahlengenerierung ist eine Aufgabe, bei der wir einige dieser Funktionen verwenden können. Dieses Dokument behandelt die verschiedenen Methoden, um dies zu erreichen.

Das obige ist der detaillierte Inhalt vonZufallszahlengenerator in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!