Zwei smarte Möglichkeiten eine Java Zufallszahl zu erzeugen

Schlagwörter: Java Programmierung

• Du möchtest deine Software mit Daten testen und dir keine Zahlen ausdenken.
• Du benötigst Stichproben, welche ein reales Verhalten simulieren.
• Du hast ein Spiel entworfen und die Akteure sollen mit zufälligen aber unterschiedlichen Größen, Rüstungsleveln usw. auftreten.

Die Einsatzmöglichkeiten für Zufallszahlen in Java sind auf jeden Fall da.

Und deshalb möchte ich dir in diesem Beitrag zwei Möglichkeiten vorstellen, wie du Zufallszahlen erzeugen kannst.

Eine Möglichkeit eine Zufallszahl zu erstellen, bietet dir die Java Klasse Random.

Der Name sagt es schon.
Hier wird etwas Zufälliges erschaffen.

Diese Klasse ist eine Standardklasse und somit im Java Paket enthalten.

Wie greifst du nun darauf zu?
Schauen wir uns die Klasse einmal in den Java API Docs genauer an.

Welche Instanzmethoden bietet die Random Klasse?
Schauen wir uns dies noch ganz kurz an.

Somit haben wir alles, was wir brauchen.
Lass es uns tun.

So erstellst du eine Zufallszahl mit der Random Klasse.

Als Erstes legst du ein Objekt an.
Mein Objekt der Klasse Random heißt „zufall“.

Originell, oder?
Das wäre der Code dazu.
Random zufall = new Random();

Und dann wendest du eine der Instanzmethoden auf diesem Objekt an:

• zufall.nextInt() liefert dir eine zufällige ganzzahlige Zahl vom Datentyp Integer
• zufall.nextDouble(); liefert dir eine zufällige Kommazahl vom Datentyp Double.
  Der Bereich beschränkt sich allerdings zwischen 0,0 und 1,0.
• Und so weiter. Du kannst dir in den API DOCS die einzelnen Methoden und deren Rückgabewerte einmal anschauen.

Jetzt lassen wir uns die Zufallszahl über die Konsole ausgeben.
Wir binden die Methode zufall.nextInt() in die Bildschirmausgabe System.out.println() ein und fertig.

Hier das komplette Beispiel.

import java.util.Random; // Importanweisung um auf die Random Klasse zuzugreifen
 
public class ZufallsZahl {
 
public static void main(String[] args) {
Random zufall = new Random(); // neues Random Objekt, namens zufall
 
System.out.println(zufall.nextInt()); //Der Rückgabewert der Methode
       // wird als Bildschirmanzeige
// ausgegeben
}
}

Klicke auf „Run“ und dir wird eine Zufallszahl im Wertebereich Integer zurückgegeben.

Okay, du kannst diese Zufallszahl auch speichern.

Du kannst eine lokale Java Variable für den entsprechenden Datentypen anlegen.
Und dann speicherst du den Wert, welchen dir die Methode zurückgibt.

Und so würde der Java Code dazu aussehen:

import java.util.Random; // Importanweisung um auf die Random Klasse zuzugreifen
 
public class ZufallsZahl {
 
public static void main(String[] args) {
Random zufall = new Random(); // neues Random Objekt, namens zufall
int zufallsZahl=zufall.nextInt(); //Speichert die Methodenrückgabe in der Variablen
 
System.out.println(zufallsZahl); //Ausgabe des Wertes der Variablen
}
}

Und das Ganze für eine Fließkommazahl zwischen 0 und 1.

import java.util.Random; // Importanweisung um auf die Random Klasse zuzugreifen
 
public class ZufallsZahl {
 
public static void main(String[] args) {
Random zufall = new Random(); // neues Random Objekt, namens zufall
double  zufallsZahl=zufall.nextDouble(); //Speichert die Methodenrückgabe in der Variablen
 
System.out.println(zufallsZahl);
}
}

Was ist mit Kommazahlen zwischen 0 und 100?

Ganz einfach.
Du kannst Zahlen einfach mit dem Ausdruck multiplizieren.

So kannst du zufällige Kommazahlen in verschiedenen Wertebereichen erstellen.

Du mulitplizierst einfach den Ausdruck mit 10, 100 oder wie auch immer.
Und heraus kommt eine zufällige Kommazahl in diesem Bereich.

import java.util.Random; // Importanweisung um auf die Random Klasse zuzugreifen
 
public class ZufallsZahl {
 
public static void main(String[] args) {
Random zufall = new Random(); // neues Random Objekt, namens zufall
double  zufallsZahl = zufall.nextDouble()*10; //Zufallszahl zwischen 0 und 10
double         zufallsZahlZwei = zufall.nextDouble()*100;//Zufallszahl zwischen 0 und 100
 
System.out.println(zufallsZahl);
System.out.println(zufallsZahlZwei);
}
}

Für ganzzahlige Zufallszahlen zwischen 0 und …. geht es auch einfacher

Und zwar bietet dir die Random-Klasse auch eine Methode an, welche den Wertebereich einschränkt.

Du kannst der „nextInt()“ Methode auch einen Wert übergeben.
Und daraus wird dann:

import java.util.Random; // Importanweisung um auf die Random Klasse zuzugreifen
 
public class ZufallsZahl {
 
public static void main(String[] args) {
Random zufall = new Random(); // neues Random Objekt, namens zufall
int zufallsZahl = zufall.nextInt(10); //Ganzahlige Zufallszahl zwischen 0 und 10
int zufallsZahlZwei = zufall.nextInt(100);//Ganze Zufallszahl zwischen 0 und 100
 
System.out.println(zufallsZahl);
System.out.println(zufallsZahlZwei);
}
}

Eine zweite Möglichkeit eine Java Zufallszahl zu erstellen, bietet die Klasse Math.

Schauen wir auch hier in den Java API Docs nach.

Diese Klasse erbt direkt von der Klasse Objekt.
Das heißt.
Du musst diese Klasse nicht einmal importieren.

Außerdem….
Bietet die Klasse Math dir keinen Konstruktor an.
Es ist also nicht möglich ein Objekt der Klasse zu erstellen.

Aber sie bietet dir jede Menge Funktionen an.
Ganz links siehst du die Rückgabewerte der Funktionen.

Und hier liegt der Vorteil dieser Java Klasse.
Du kannst nämlich eine Zufallszahl erzeugen, ohne vorher ein Objekt anlegen zu müssen.

Und wie geht’s?
Die Klasse Math bietet dir eine Methode random() an.
Du siehst der Rückgabewert ist ein Double.

public class ZufallsZahl {
 
public static void main(String[] args) {
System.out.println(Math.random()); // Einbindung der Rückgabe in Ausgabe
}
}

Und natürlich kannst du diesen Wert auch speichern.

public class ZufallsZahl {
 
public static void main(String[] args) {
double zufallZahl = Math.random(); //Der Rückgabewert der Math-Methode wird gespeichert
System.out.println(zufallZahl); // Ausgabe des Wertes
}
}

Und du kannst dir auch Zufallszahlen zwischen 0 und 100 ausgeben lassen.

public class ZufallsZahl {
 
public static void main(String[] args) {
double zufallZahl = Math.random()*100; //Java Zufallszahlen zwischen 0 und 100
double zufallZahlZwei = Math.random()*10; //Java Zufallszahlen zwischen 0 und 10
System.out.println(zufallZahl); // Ausgabe des Wertes
System.out.println(zufallZahlZwei); //Ausgabe der zweiten Zufallszahl
}
}

Die Random-Methode der Math-Klasse liefert dir erst einmal nur Kommazahlen.
Was ist aber, wenn du ganze Zahlen brauchst?

Willst du ganze Zufallszahlen mit der Math-Klasse erzeugen, musst du entweder runden oder casten.

Es ist kein Problem.

Die Math Klasse bietet dir eine Methode zum Runden von Zahlen an.
Die Methode round(double a) erwartet einen Double Wert und liefert einen Long-Wert zurück.

public class ZufallsZahl {
 
public static void main(String[] args) {
long zufallZahl = Math.round( Math.random()*100); //Java Zufallszahlen zwischen 0 und 100
long zufallZahlZwei = Math.round( Math.random()*10); //Java Zufallszahlen zwischen 0 und 10
System.out.println(zufallZahl); // Ausgabe des Wertes
System.out.println(zufallZahlZwei); //Ausgabe der zweiten Zufallszahl
}
}

Achte schön auf die Klammerung. Von innen nach außen.
Erst muss der innere Ausdruck ausgewertet werden.
Dieser wird dann der äußeren Klammer übergeben.

Jetzt bekommst du aber nur long-Werte.
Was ist mit Integer-Werten?
Auch das geht. Du musst diese aber casten.

public class ZufallsZahl {
 
public static void main(String[] args) {
int zufallZahl = (int) (Math.random()*100); //Java Zufallszahlen auf int casten
int zufallZahlZwei = (int) (Math.random()*10); //Java Zufallszahlen durch Integer Cast
System.out.println(zufallZahl); // Ausgabe des Wertes
System.out.println(zufallZahlZwei); //Ausgabe der zweiten Zufallszahl
}
}

Auch hier ist wieder auf die Klammerung zu achten.
(Math.random()*100) ist ein Ausdruck, welcher in Klammern stehen muss.
Und dieser ganze Ausdruck wird durch (int) in Integer gewandelt.

Eine Frage bleibt noch.
Wie erzeugt man Zufallszahlen zwischen 50 und 60 in Java?
Die Antwort lautet durch Methoden.

So kannst du Zufallszahlen zwischen zwei Wertebereichen in Java erzeugen.

Wie wäre es mit einer Methode, welcher beim Aufruf zwei Werte übergeben werden.

• Untere Grenze beispielsweise 50
• Obere Grenze beispielsweise 60

Die Methode erzeugt dann eine Zufallszahl mit der nextInt(60) Methode der Random Klasse.
Dadurch wird diese Zufallszahl zwischen 0 und 60 sein.

So dann haben wir die obere Grenze.

• Eine while Schleife wertet dann den Wert der erzeugten Zahl aus.
  Wenn diese Zahl unterhalb der unteren Grenze (50) liegt, dann wird die nächste Zufallszahl ermittelt.
  Und diese Zahl ist wieder zwischen 0 und 60.
• Und diese Zahl wird geprüft.
  Ist die Zahl unter der unteren Grenze von 50.
  Ab in die Schleife und nächste Zahl generieren.
• Bis zum Zeitpunkt, dass die Zufallszahl zwischen 50 und 60 ist.
  Und dann wird diese ausgegeben.

Und dies wäre der Java Code mit einem Random-Objekt.

import java.util.Random;
 
public class ZufallsZahl {
 
static void erzeugeZufallRandom(int untereGrenze, int obereGrenze){
Random zufall = new Random(); // neues Objekte der Random Klasse
int zufallZahl = zufall.nextInt(obereGrenze); // next Int Methode mit Argument
 
while (zufallZahl < untereGrenze){ //Beding. zufallsZahl muss kleiner als Argument sein
zufallZahl = zufall.nextInt(obereGrenze); //finde nächste Zahl
}
System.out.println(zufallZahl); //Gib Zufallszahl aus
}
 
public static void main(String[] args) {
erzeugeZufallRandom(50,60);
}
}

Klicke auf „Run“ und schau zu, wie Java Zufallszahlen für dich anfertigt.
Cool, oder?

Und jetzt das Ganze noch mit der Math.random() Methode.

public class ZufallsZahl {
 
static void erzeugeZufallMath(int untereGrenze, int obereGrenze){
int zufallZahl = (int)(Math.random()*obereGrenze); // ZufallsZahl innerhalb der oberen Grenze
 
while (zufallZahl < untereGrenze){ //Bed. zufallsZahl muss kleiner als Argument sein
zufallZahl = (int)(Math.random()*obereGrenze); //finde nächste Zahl
}
System.out.println(zufallZahl); //Gib Zufallszahl aus
}
 
public static void main(String[] args) {
erzeugeZufallMath(50,60);
}
}

Ganz kurz noch einmal Schritt für Schritt:

• Zuerst wird die Math.random() Methode aufgerufen.
  Diese gibt eine Kommazahl zwischen 0 und 1 zurück.
• Dadurch dass dieser Wert mit der entsprechenden Obergrenze (in diesem Fall 60) multipliziert wurde, erhält das Programm eine Kommazahl zwischen 0 und 60.
• Dann wird dieser Wert in eine ganze Zahl umgewandelt. (int)
  Achte wieder auf die entsprechende Klammerung beim Umwandeln (Casten) der Datentypen.

Und diese Zufallszahl wird jetzt in der while Schleife ausgewertet.
Die Schleife wird solange durchgeführt bis der Wert größer als der untere Grenzwert (50) ist.

Innerhalb der Schleife werden immer wieder Zufallszahlen zwischen 0 und dem oberen Grenzwert (60) erzeugt.
Erst wenn der Zufallswert über dem unteren Grenzwert liegt, wird diese als Zufallszahl zurückgegeben.

Du kannst eine Java Zufallszahl in einen bestimmten Bereich aber auch auf die herkömmliche Weise erstellen.

Und damit meine ich die Math.random()-Methode ohne Schleife.

So geht’s.

public class ZufallsZahl {

	static void erzeugeZufallMath(int untereGrenze, int obereGrenze) {
		int differenz = obereGrenze - untereGrenze;
		int zufallZahl = (int) (Math.random() * differenz) + untereGrenze;
	}

	public static void main(String[] args) {
		erzeugeZufallMath(50, 60);
	}
}

Die Methode bekommt wieder zwei Werte.
Jetzt wird aber die Differenz zwischen dem oberen und unteren Wert berechnet und zwischengespeichert.
Bei einer Übergabe von 50 und 60 wäre dies 10.

Jetzt erstellt die Math.random() Methode einen Wert zwischen 0 und 10 und castet diesen wieder auf einen Integer Datentypen.

Und dann wird der untere Grenzwert (50) dazu addiert.

Zusammenfassung:

• Zufallszahlen kannst du in Java mit der Math-Klasse oder der Random-Klasse erzeugen.
• Die Math-Klasse bietet den Vorteil, dass du kein Objekt anlegen musst.
  Außerdem sind die Math.Random() Methode statisch, so dass du ohne weiteres einen Zugriff hast.
• Falls du in Java Zufallszahlen zwischen einem bestimmten Wertebereich anlegen willst, kannst du dies über eigene Methoden umsetzen.