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 organisierst und verwaltest du ganz bequem deine Java Projekte

Du kennst das auch. Denn du bist ja fleißig. Und weil du so fleißig bist, hast du mitunter auch mehrere Java Projekte gleichzeitig laufen. Und dann kommt es vor, dass du enorm viele Java Projekte am Laufen hast. Und dein Package-Explorer wird extrem unübersichtlich. In diesem Beitrag möchte ich dir zwei Varianten vorstellen, wie du […]

Java Übung: Alles beginnt mit Hello World

Java Übung Hello World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ public class HelloWorld{ public static […]

Java Übung 31: Speichere deine Würfe im Array

Java Übung Array Würfelspiel

In dieser Java Übung soll ein Würfelspiel simuliert werden. Lege eine Klasse namens, Würfelspiel an. Diese Klasse enthält eine statische Methode, namens würfeln(). Diese Methode erwartet einen Parameter vom Datentyp Integer, namens „anzahlWuerfe“. Diese Variable/Parameter repräsentiert die Anzahl der Würfe. Nachdem der Methode die Anzahl der Würfe übergeben wurde, soll die Methode Zufallszahlen zwischen 1 […]

So kannst du gelöschte Java Projekte oder Dateien in Eclipse wieder herstellen

Wahrscheinlich passiert es jedem einmal, dass man versehentlich Dateien löscht. Und dann? Die Wut ist riesig, weil man ja alles nochmal schreiben muss. In Eclipse hast du die Möglichkeit sämtliche Dateien wieder herzustellen. In diesem Beitrag möchte ich dir demonstrieren, wie du gelöschte Java Klassen, Dateien, Projekte oder Packages wieder herstellen kannst.

So lassen sich aus Java Klassen Instanzen erstellen

Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen. Im Einführungsbeispiel hast du bereits gelernt, wie du: Instanzvariablen bzw. Attribute anlegst Wie du aus einer normalen Java Klasse eine Programmstart Klasse machst In diesem Artikel erfährst du: Was Objekte bzw. Instanzen sind. Wie sich Objekte zusammensetzen. Wo und wie du Instanzen aus Java Klassen […]

So kannst du ein neues Java Projekt mit Eclipse anlegen und konfigurieren

Java Projekt anlegen Eclipse

In diesem Beitrag möchte ich dir zeigen, wie du ein neues Java Projekt mit Eclipse anlegen kannst. Ich werde dir außerdem einen kurzen Überblick über die Konfigurationsmöglichkeiten geben. Dann gebe ich dir noch eine ganz einfache Schritt-für-Schritt-Anleitung für dein allererstes Java Projekt und ich zeige dir, was nach dem Anlegen des Projektes eigentlich passiert ist.