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

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 […]

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]

Java Exklusives Oder – So nutzt du den Xor Operator

Java exklusives oder

In diesem Beitrag möchte ich dir den Xor Operator von Java vorstellen. Dieser Operator wird auch als ausschließendes oder exklusives Oder bezeichnet. Ein Beispiel: Was wilst du heute zum Mittag essen: Fleisch oder Fisch? Auf diese Frage gibt es nur eine Antwort. Es ist entweder Fisch oder Fleisch. Niemals beides. Das Eine schließt das andere […]

So kannst du Java Arrays mit for Schleife füllen und auslesen

Java Arrays For Schleife

Wir haben in einem anderen Beitrag bereits über Java Arrays gesprochen. So ein Array speichert Zahlen, Texte oder Objekte in eine Art Liste. Und dann kannst du ganz bequem über den Index das Array füllen und die bereits enthaltenen Werte abrufen. Ganz bequem? So, wie ich dich aus dem letzten Beitrag entlassen habe, war das […]

Java Vererbung findet auch zwischen Einkaufstüten und Polizeiautos statt

Java Vererbung

„Manchmal findet Java Vererbung auch zwischen Einkaufstüten und Polizeiautos statt“ Irrer Titel, oder? Aber mal Hand aufs Herz. Was haben eigentlich eine Einkaufstüte und ein Polizeiwagen gemeinsam? Ich verrate dir etwas: Du kannst die Verbindung nicht erkennen, denn ich habe dir nicht alles verraten. Es fehlt noch ein wichtiger Aspekt – eine Verbindung zwischen beiden. […]

Nutze die richtigen Methoden zum Java Lernen

Java lernen Methoden

Ich lernte die Java Programmierung auf die klassische Art. Ich kaufte mir das erste Buch und los ging es. „Jetzt wirst du Java lernen“ – sagte ich zu mir. Ich war relativ schnell ziemlich frustriert, denn irgendwie fehlten mir ein paar Zusammenhänge. Kennst du das? Du hast ein Wissensfetzen und noch einen. Aber das Wichtigste. […]

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Java Methoden Rückgabetypen

Was du vereinbarst, das bekommst du zurück. Ach wäre es schön, wenn alles im Leben so funktionieren würde. Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden. Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren. Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst…. Lass mich dir zeigen, wofür du den Kram […]

So kannst du in Java Und Verknüpfung anlegen und auswerten

Java Und

In Java stehen dir eine Menge Operatoren zur Verfügung. Einer dieser Operatoren ist der Und-Operator. Dies ist ein logischer Operator, da dieser sogenannte Wahrheitswerte mit einander verknüpft. Also…. Was erwartet dich in diesem Beitrag? Zuerst möchte ich dir die Aussagenlogik hinter dem Und-Operator zeigen. Also wann sind Aussagen wahr und wann sind diese falsch. Dann […]