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 lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

Nutze das Keyword this für deine Java Konstruktoren

Java konstruktoren this

Es ist gemein. Wahrscheinlich hast den Beitrag zu den lokalen Variablen gelesen. Vielleicht hast du auch den Artikeln zum Anlegen und Überladen von Java Konstruktoren gelesen. Und wenn du die beschriebene Inhalte selbst ausprobiert hast…… Dann hast du dir wahrscheinlich sehr viele lokale Variablennamen für die Parameterliste ausdenken müssen.

Java Duales Zahlensystem – Binäre Zahlen in Java umwandeln

Java Dual System

Das duale Zahlensystem hat viele Bezeichnungen. Oft wird auch es Dualsystem oder Binärsystem genannt. Es besteht aber immer aus 2 Zahlen. Man verwendet oft die Zahlen 0 und 1. Es können aber auch sämtliche anderen Zahlenpaare sein. Zum Beispiel 7 und 175 sind für sich genommen, auch ein normales Zahlenpaar und somit ein Dualsystem. Mit […]

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.

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]

So implementierst du Instanzmethoden in deine Java Klasse

Java Instanzmethoden

In einen der letzten Beiträge habe ich dir gezeigt, wie du eine Klasse anlegen kannst. Ich habe die Klasse „Mensch“ oder „Human“ angelegt und wir haben die erste Instanzvariable implementiert. Dein Code sollte jetzt so aussehen: public class Human { int size=156;//size in centimeter } In diesem Beitrag werde ich dir zeigen, wie du Java […]

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

So nutzt du die While Schleife in deinem Java Programm

Java While Schleife

Manchmal ist es wichtig, Dinge einmal öfter zu tun. Bei der Java Programmierung kann es schonmal sein, dass du einen Code mehrfach ausführen lassen musst. Zum Beispiel die Zahlen eins bis zehn. Ein Java Programm, welches die Zahlen eins bis zehn wiedergibt. Na wie wäre das? Der Java Code dazu würde so aussehen: public class […]

So erstellst du deine ersten Java Klassen mit Eclipse

Java Klassen sind Baupläne für Java Objekte. Und da Java eine objektorientierte Programmiersprache ist, sind Java Klassen somit ein elementarer Bestandteil. In diesem Beitrag möchte ich dir zeigen, wie du eine Java Klasse in Eclipse erstellen kannst. Ich möchte dir außerdem zeigen, was physikalisch in deinem Projekt passiert. Ganz zum Schluss zeige ich dir noch, […]

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