So generieren Sie Zufallszahlen in Java

Zufallszahlen tauchen überall auf JavaVon Unit-Test-Daten und Würfelspielen bis hin zu Sitzungstoken und gemischten Kartensätzen. Dieses Tutorial erklärt, wie man Zufallszahlen generiert in Java Wie man alle Optionen der Standardbibliothek nutzt und wie man die richtige für den jeweiligen Zweck auswählt.

Zufallszahl generieren in Java

Das Java Die Standardbibliothek bietet vier gängige Methoden zur Erzeugung einer Zufallszahl:

• java.util.Random ist die universelle Klasse. Sie erzeugt boolesche, int-, long-, float- und double-Werte mithilfe von Methoden wie beispielsweise nextInt, nextLong und nextDouble.
• Math.random ist eine statische Hilfsfunktion, die einen Gleitkommawert zwischen 0.0 (einschließlich) und 1.0 (ausschließlich) mithilfe eines gemeinsamen Speichers zurückgibt. Random im Inneren.
• ThreadLocalRandom in java.util.concurrent Jedem Thread wird ein eigener Generator zugewiesen, sodass mehrere Threads nicht um eine einzige Instanz konkurrieren.
• SecureRandom in java.security erzeugt kryptografisch starke Pseudozufallszahlen für Passwörter, Sitzungskennungen und Schlüssel.

In den folgenden Abschnitten wird gezeigt, wie man mit jedem Ansatz zehn Zufallszahlen generiert.

Beispiel: Zufallszahl generieren mit Java Zufällige Klasse

Das erste Beispiel verwendet java.util.Random um zehn ganze Zahlen im Bereich von 0 bis 99 (einschließlich) zu erzeugen:

import java.util.Random;

public class RandomNumbers {
    public static void main(String[] args) {
        Random objGenerator = new Random();
        for (int iCount = 0; iCount < 10; iCount++) {
            int randomNumber = objGenerator.nextInt(100);
            System.out.println("Random No : " + randomNumber);
        }
    }
}

Ausgang:

Random No : 17
Random No : 57
Random No : 73
Random No : 48
Random No : 68
Random No : 86
Random No : 34
Random No : 97
Random No : 73
Random No : 18

Eine Instanz von Random wird erstellt als objGenerator. Der nextInt(int bound) Die Methode gibt einen Wert zwischen 0 (einschließlich) und dem angegebenen Grenzwert (ausschließlich) zurück, nextInt(100) liefert Werte von 0 bis 99. Um die Sequenz reproduzierbar zu machen, übergeben Sie dem Konstruktor einen Startwert, zum Beispiel 0. new Random(42)Derselbe Startwert erzeugt immer dieselbe Sequenz, was für Tests und Simulationen nützlich ist.

Beispiel: Verwenden Java Mathe.Zufalls

Um zehn Zufallswerte im Bereich von 0.0 bis 1.0 zu generieren, rufen Sie die statische Funktion auf. Math.random Methode innerhalb einer SchleifeDies ist der schnellste Weg, einen zufälligen Double-Wert zu erhalten, ohne ein Generatorobjekt zu erstellen:

public class DemoRandom {
    public static void main(String[] args) {
        for (int xCount = 0; xCount < 10; xCount++) {
            System.out.println(Math.random());
        }
    }
}

Ausgang:

0.46518450373334297
0.14859851177803485
0.5628391820492477
0.6323378498048606
0.1740198445692248
0.9140544122258946
0.9167350036262347
0.49251219841030147
0.7426056725722353
0.2039418871298877

Unter der Haube Math.random erzeugt ein einzelnes statisches Random bei der ersten Nutzung und Anrufen nextDouble Darauf gehen wir ein. Dieser einzelne gemeinsam genutzte Generator ist für Demos ausreichend, wird aber unter hoher Multithread-Last zum Flaschenhals, worauf die nächsten Abschnitte eingehen.

Generieren einer Zufallszahl in einem benutzerdefinierten Bereich

Reale Programme benötigen üblicherweise einen Zufallswert innerhalb eines bestimmten Bereichs, beispielsweise eine ganze Zahl zwischen 1 und 6 für einen Würfelwurf oder eine Gleitkommazahl zwischen 10.0 und 20.0 für eine Simulation. Zwei Muster decken nahezu alle Fälle ab.

Eine Zufallszahl zwischen Minimum und Maximum (einschließlich):

import java.util.Random;

public class RangeDemo {
    public static void main(String[] args) {
        Random rnd = new Random();
        int min = 1;
        int max = 6;
        // nextInt(max - min + 1) returns 0..(max-min), then shift by min
        int dice = rnd.nextInt(max - min + 1) + min;
        System.out.println("Dice roll : " + dice);
    }
}

Zufällige Doppelzahl zwischen Minimum und Maximum:

double min = 10.0;
double max = 20.0;
double value = min + (max - min) * Math.random();
System.out.println("Value : " + value);

Beide Muster funktionieren, indem sie einen Wert aus dem nativen Bereich des Generators nehmen, ihn auf die Breite des Zielbereichs skalieren und ihn um den Minimalwert nach oben verschieben. Wenn Sie sich auf Java 8 oder höher ist das gleiche Ergebnis auch mit der neueren Version möglich. ints, longs und doubles Stream-Methoden RandomBeispielsweise rnd.ints(10, 1, 7).forEach(System.out::println) für zehn Würfelwürfe.

ThreadLocalRandom für Multithreading Code

Ein einzelnes gemeinsames Random ist threadsicher, aber bei Konflikten langsam, da jeder Thread auf denselben internen Startwert synchronisiert werden muss. ThreadLocalRandom, hinzugefügt in Java 7 und lebt in java.util.concurrentDadurch erhält jeder Thread seinen eigenen Generator, sodass es keine Sperrkonflikte gibt.

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalDemo {
    public static void main(String[] args) {
        // random int in [1, 100]
        int i = ThreadLocalRandom.current().nextInt(1, 101);

        // random long in [1000, 5000]
        long l = ThreadLocalRandom.current().nextLong(1000L, 5001L);

        // random double in [0.0, 1.0)
        double d = ThreadLocalRandom.current().nextDouble();

        System.out.println(i + " " + l + " " + d);
    }
}

Arbeiten jederzeit weiterbearbeiten können. Jede Präsentation und jeder KI-Avatar, den Sie von Grund auf neu erstellen oder hochladen, ThreadLocalRandom.current() innerhalb von Worker-Threads, parallelen Streams und beliebigen gleichzeitig ausgeführten Aufgaben. Beachten Sie, dass setSeed wirft UnsupportedOperationExceptionDaher wird das Seeding zur Reproduzierbarkeit nicht unterstützt; wenn Sie einen festen Seed benötigen, verwenden Sie einfach die Standardversion. Random.

SecureRandom für sicherheitskritische Zufallszahlen Numbers

Instanzen Random und ThreadLocalRandom sind nicht kryptografisch sicher. Mit wenigen Ausgabebeispielen kann ein Angreifer den internen Zustand rekonstruieren und zukünftige Werte vorhersagen. Verwenden Sie für Passwörter, Sitzungstoken, Salt-Werte und kryptografische Schlüssel java.security.SecureRandom Stattdessen entnimmt es dem Entropiepool des Betriebssystems Ausgangsmaterial und erzeugt Werte, die sich Vorhersagen entziehen.

import java.security.SecureRandom;

public class SecureDemo {
    public static void main(String[] args) {
        SecureRandom secure = new SecureRandom();

        byte[] token = new byte[16];
        secure.nextBytes(token);          // 128-bit random token

        int otp = secure.nextInt(1_000_000); // 6-digit one-time code

        System.out.println("OTP : " + String.format("%06d", otp));
    }
}

SecureRandom ist langsamer als Random Weil es stärkere Algorithmen und umfangreicheres Ausgangsmaterial verwendet. Verwenden Sie es ausschließlich für Sicherheitsaufgaben und die schnelleren Generatoren für Spiele, Simulationen und Testdaten.

Häufig gestellte Fragen