Skip to main content

Zwei smarte Möglichkeiten eine Java Zufallszahl zu erzeugen

Java Zufallszahl – Wieso?
In der Java Programmierung benötigst du immer wieder einmal Zufallszahlen.

  • 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.

Java Zufallszahl Random Klasse

Ganz oben siehst du schon, in welchem Package die Klasse steht.
Du musst somit eine Importanweisung anlegen, um auf diese Klasse zugreifen zu können.
import java.util.Random;
Java Zufallszahl Random Importanweisung

Weiter unten in den API Docs der Random Klasse siehst du die Konstruktoren, welche dir diese Klasse anbietet.
Es sind zwei Stück.
Uns interessiert, in diesem Beispiel, nur der default-Konstruktor.
Also der ohne Parameterliste.
Java-Zufallszahl-Random-Konstruktor

Du musst somit ein Objekt der Random Klasse erstellen.
Und dann kannst du Instanzmethoden an diesem Objekt aufrufen.

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

Java Zufallszahl Random Methoden

Im Bild siehst du die Methoden.
Links dazu siehst du die entsprechenden Rückgabewerte bzw. Rückgabedatentypen.

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.

Java Zufallszahl Math Klasse

Ganz oben steht wieder das package für die Klasse.
Diese Klasse befindet sich im package „java.lang.“

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.

Java Zufallszahl Math Statische Methoden

Außerdem erkennst du, dass die Methoden statisch sind.
Klar, wenn du kein Objekt erstellen kannst, müssen die Methoden statisch sein.

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.

Java Zufallszahl Random Math Klasse

Es wird somit eine Kommazahl zurückgegeben.
Und so geht’s.


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.

Java Zufallszahl While Schleife

PS.
Das „+“ im Bild steht für „und“.
Also zwischen 0 und 60. 🙂
Ist nicht ganz deutlich.

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.

Ähnliche Beiträge

So kannst du Java installieren

Java installieren

Bevor du loslegst und deine ersten Java Programme schreibst, benötigst du die entsprechende Arbeitsumgebung. Du solltest also Java installieren. Und diese Arbeitsumgebung beinhaltet dann Bibliotheken für die einzelnen Java-Standard-Klassen, Dateien um deine Programme auszuführen. Dateien um deine Programme zu packen, Logische Verzeichnisstrukturen

Das Java Leben ist einfacher mit For-Schleife

Java For Schleife Aufbau

In einem anderen Artikeln habe ich bereits über Schleifen in Java gesprochen. In diesem Artikel möchte ich dir eine ganz besondere Schleife vorstellen. Warum ist diese so toll? Sie hat einen integrierten Schleifenzähler. Die Schleife zählt also bei jedem Durchlauf automatisch mit. Aber dazu gleich mehr…. Lass uns einmal so eine For Schleife anlegen.

So verwendest du die Java Codeblöcke zur Automatisierung

Java Codeblöcke

In diesem Beitrag geht es um den Einsatz von Java Codeblöcken oder Initialisierungsblöcken. Viele Wege führen nach Rom. Oder Alle Wege führen nach Rom. Heißt es in einem alten Sprichwort. Und so ähnlich ist es bei der Java Programmierung. In diesem Beitrag möchte ich dir einen weiteren Weg vorstellen, wie du Variablen eines Java Objektes […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

Java Konsolenausgaben mit formatierten Zahlen

Java Konsolenausgaben Zahlen

Java Konsolenausgaben erzeugst du mit der System.out.println()-Anweisung. Dies ist relativ einfach. Aber es ist mitunter nicht ganz praktisch. Und zwar immer dann, wenn Zahlen im Spiel sind. Die Zahlen welche dann auf deiner Java Konsole erscheinen, sind unformatiert. Sie haben zu viele Kommastellen. Oder für eine bessere Darstellung benötigst du den Tausenderpunkt. Vielleicht möchtest du […]

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag

So lassen sich Java Arrays kopieren

Java Arrays kopieren

Java Arrays kopieren oder klonen…. Was heißt das eigentlich? Eine Kopie ist eine Reproduktion bzw. die Nachbildung eines Originals. Somit ist jede Fotographie – die Abbildung einer bestimmten optischen Wirklichkeit, zu einem festen Zeitpunkt. Die Kopie einer Buchseite ist das optische Abbild dieser spezifischen Buchseite – auch zu einem festen Zeitpunkt. Wichtig in diesem Zusammenhang […]

Java Exceptions Handling – Fehler- und Ausnahmenbehandlung in Java

Java Exceptions Handling

Java Exceptions Handling umfasst den richtigen Umgang mit Ausnahmen und Fehlern. Wie geht das? Und braucht man so etwas wirklich? Vielleicht sagst du jetzt: „Brauch ich nicht. Ich mache niemals Fehler.“ Doch… Bei der Java Fehlerbehandlung geht es nicht ausschließlich nur um deine Programmierfehler. Es geht auch um falsche Nutzereingaben, Hardware- und Ablauffehler. Und deshalb […]

Der Aufbau von Java Klassen

Java Klassen Aufbau

Jedes Java Programm besteht aus Java Klassen. Doch wie sind diese aufgebaut? Wie setzt sich die Struktur zusammen? Wo befinden sich Klassen hierarchisch? Was kommt in die Klassen rein und wie wird es integriert? Das sind die Fragen, welche ich in diesem Artikel beantworten werde. Doch bevor wir bei den Klassen ansetzen, müssen wir eine […]