Wichtige Konstruktoren
Wichtige Methoden
Konstruktoren
Random()↑
Funktion:
Erzeugt ein neues Objekt der Klasse Random, das immer neue Zufallszahlen generiert.
Random(long seed)↑
Funktion:
Erzeugt ein neues Objekt der Klasse Random, das immer die gleichen Zufallszahlen produziert. Das könnte beispielsweise sinnvoll sein, wenn man verschiedene Sortieralgorithmen für 1000 Zufallszahlen testen möchte.
Methoden
nextInt() / nextLong()↑
Syntax:
public int nextInt()
public long nextLong()
Rückgabewert:
int bzw. long
Funktion:
Diese Methode liefert alle möglichen int-Zahlen bzw. long-Zahlen, sowohl positive wie auch negative.
Codebeispiel:
int zahl = zufall.nextInt(); System.out.println(zahl);
nextInt(int bound)↑
Syntax:
public int nextInf(int bound)
Rückgabewert:
int
Funktion:
Liefert eine Zufallszahl zwischen 0 und bound-1.
Codebeispiel:
int wuerfel = zufall.nextInt(6) + 1; // Würfelzahl 1–6
Erläuterung:
Wird sehr häufig benutzt, wenn man einen int-Array mit Zufallszahlen füllen möchte, beispielsweise um einen Sortieralgorithmus zu testen.
nextDouble()↑
Syntax:
public double nextDouble()
Rückgabewert:
double
Funktion:
Liefert eine Zufallszahl im Bereich >= 0 und < 1.
nextBoolean()↑
Syntax:
public double nextBoolean()
Rückgabewert:
true, false
Funktion:
Liefert eine zufällige Ja/Nein-Entscheidung
Codebeispiel:
if (zufall.nextBoolean()) {
System.out.println("Kopf");
} else {
System.out.println("Zahl");
}
nextGaussian()↑
Syntax:
public double nextGaussian()
Rückgabewert:
double
Funktion:
Liefert eine Zufallszahl nach der Normalverteilung.
Codebeispiel:
import java.util.Random;
public class NormalverteilungKIBetter
{
Random zGenerator;
public NormalverteilungKIBetter()
{
zGenerator = new Random();
test(40); // Erzeugung von 40 Klassen
}
public void test(int anzahlDerKlassen)
{
// Grenzen automatisch erzeugen
double min = -3.0;
double max = 3.0;
double schritt = (max - min) / anzahlDerKlassen;
double[] wert = new double[anzahlDerKlassen];
for (int i = 0; i < wert.length; i++)
{
wert[i] = min + i * schritt;
}
int[] zahlen = new int[anzahlDerKlassen];
// Zufallszahlen generieren und einsortieren
for (int i = 0; i < 20000; i++)
{
double zZahl = zGenerator.nextGaussian();
for (int j = 0; j < wert.length; j++)
{
if (zZahl < wert[j])
{
zahlen[j]++;
break;
}
}
}
// Maximum ermitteln
int maxAnzahl = 0;
for (int n : zahlen)
{
if (n > maxAnzahl)
maxAnzahl = n;
}
// Ausgabe mit Histogramm
System.out.printf("%10s %10s %s%n", "Grenze", "Anzahl", "Histogramm");
System.out.println("--------------------------------------------------");
for (int z = 0; z < zahlen.length; z++)
{
// Anzahl Sterne skalieren
int sterne = (int) Math.round((zahlen[z] / (double) maxAnzahl) * 50);
System.out.printf("%10.1f %10d ", wert[z], zahlen[z]);
for (int s = 0; s < sterne; s++)
System.out.print("*");
System.out.println();
}
}
}
Die Konsolenausgabe des Programms:
Grenze Anzahl Histogramm
--------------------------------------------------
-3,0 24 *
-2,9 18 *
-2,7 26 *
-2,6 35 *
-2,4 61 ***
-2,3 74 ***
-2,1 92 ****
-2,0 147 ******
-1,8 202 ********
-1,7 285 ************
-1,5 327 **************
-1,4 407 *****************
-1,2 532 **********************
-1,1 680 ****************************
-0,9 741 *******************************
-0,8 841 ***********************************
-0,6 969 ****************************************
-0,5 1048 ********************************************
-0,3 1088 *********************************************
-0,1 1151 ************************************************
0,0 1200 **************************************************
0,1 1201 **************************************************
0,3 1116 **********************************************
0,4 1122 ***********************************************
0,6 1020 ******************************************
0,8 974 *****************************************
0,9 872 ************************************
1,0 746 *******************************
1,2 665 ****************************
1,3 539 **********************
1,5 469 ********************
1,6 324 *************
1,8 269 ***********
2,0 206 *********
2,1 166 *******
2,3 112 *****
2,4 87 ****
2,6 53 **
2,7 35 *
2,8 29 *
Dieses Programm, das ich mit Hilfe von ChatGPT entwickelt habe, testet diese Methode der Klasse Random. Es werden 20.000 Zufallszahlen erzeugt, die dann in 40 Katergorien unterteilt werden. In einem Array entsprechender Größe wird dann die Anzahl der Zufallszahlen gespeichert, die in die jeweilige Kategorie fallen. Die Daten werden dann übersichtlich mit printf() ausgegeben, und außerdem werden die Daten halbgraphisch als skaliertes Histogramm dargestellt. Um eine richtige Normalverteilung zu erzeugen, muss man schon mindestens 10.000 Zufallszahlen produzieren, sonst gibt es deutliche Täler und Berge in der Glockenkurve.
setSeed(long seed)↑
Syntax:
public void setSeed(long seed)
Rückgabewert:
void
Funktion:
Der Aufruf dieser Methode startet den Zufallsgenerator quasi neu. Wenn zwei Zufallsgenerator-Objekte mit dem gleichen seed gestartet werden, produzieren sie die gleiche Folge von Zufallszahlen, was man mit folgendem Code überprüfen kann:
Codebeispiel:
import java.util.Random;
public class TestSeed
{
public static void main(String[] args)
{
Random r1 = new Random();
r1.setSeed(12345);
Random r2 = new Random();
r2.setSeed(12345);
for (int i = 0; i < 5; i++)
{
System.out.println(r1.nextInt(100) + " - " + r2.nextInt(100));
}
}
}
Konsolenausgabe:
51 - 51 80 - 80 41 - 41 28 - 28 55 - 55
Wie der Test zeigt, werden tatsächlich die gleichen fünf Zufallszahlen produziert. Auch wenn man die Klasse neu kompiliert und dann startet, werden wieder die gleichen Zahlen erzeugt:
51 - 51 80 - 80 41 - 41 28 - 28 55 - 55
Auch nach einem Neustart der Java-IDE bleibt es dabei, es werden stets die selben Zahlen erzeugt. Selbst ein Neustart des Rechners verändert die Zahlen nicht. Das Verhalten von setSeed() hängt nicht vom Rechnerzustand oder vom Betriebssystem ab, sondern nur vom internen Algorithmus in der Java-Klasse Random.
Wenn man den Zufallsgenerator ohne setSeed() startet, wird die Systemzeit des Rechners ausgelesen und als Seed verwendet. So erhält man jedes Mal eine neue Folge von Zufallszahlen.
Typische Anwendungen von setSeed()
- Reproduzierbare Tests: Wenn man in Experimenten, Simulationen oder Unit-Tests immer dieselben Zufallswerte benötigt.
- Debugging: Man kann durch den festen Seed sicherstellen, dass ein Programm immer gleich läuft, auch wenn es Zufallszahlen verwendet.
- Vergleich von Algorithmen: Zwei verschiedene Verfahren können mit denselben Zufallsfolgen gefüttert werden, um die Ergebnisse fair zu vergleichen.