Wie generiere ich zufällige Ganzzahlen innerhalb eines bestimmten Bereichs in Java?

Wie generiere ich einen zufälligen intWert in einem bestimmten Bereich?

Ich habe folgendes versucht, aber diese funktionieren nicht:

Versuch 1:

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

Versuch 2:

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.

In Java 1.7 oder höher lautet die Standardmethode hierfür:

import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

Siehe das entsprechende JavaDoc . Dieser Ansatz hat den Vorteil, dass eine java.util.Random- Instanz nicht explizit initialisiert werden muss. Dies kann bei unsachgemäßer Verwendung zu Verwirrung und Fehlern führen.

Umgekehrt gibt es jedoch keine Möglichkeit, den Startwert explizit festzulegen, sodass es schwierig sein kann, Ergebnisse in Situationen zu reproduzieren, in denen dies nützlich ist, z. B. beim Testen oder Speichern von Spielzuständen oder ähnlichem. In diesen Situationen kann die unten gezeigte Technik vor Java 1.7 verwendet werden.

Vor Java 1.7 ist dies standardmäßig wie folgt:

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

Siehe das entsprechende JavaDoc . In der Praxis ist die Klasse java.util.Random häufig java.lang.Math.random () vorzuziehen .

Insbesondere muss das Zufallsgenerierungsrad nicht neu erfunden werden, wenn die Standardbibliothek eine einfache API enthält, um die Aufgabe auszuführen.

Beachten Sie, dass dieser Ansatz voreingenommener und weniger effizient ist als der nextIntAnsatz https://stackoverflow.com/a/738651/360211

Ein Standardmuster, um dies zu erreichen, ist:

Min + (int)(Math.random() * ((Max - Min) + 1))

Die Java Math-Bibliotheksfunktion Math.random () generiert einen doppelten Wert im Bereich [0,1). Beachten Sie, dass dieser Bereich die 1 nicht enthält.

Um zuerst einen bestimmten Wertebereich zu erhalten, müssen Sie mit der Größe des Wertebereichs multiplizieren, den Sie abdecken möchten.

Math.random() * ( Max - Min )

Dies gibt einen Wert im Bereich zurück [0,Max-Min), in dem 'Max-Min' nicht enthalten ist.

Wenn Sie beispielsweise möchten [5,10), müssen Sie fünf ganzzahlige Werte abdecken, damit Sie sie verwenden können

Math.random() * 5

Dies würde einen Wert im Bereich zurückgeben [0,5), in dem 5 nicht enthalten ist.

Jetzt müssen Sie diesen Bereich auf den Bereich verschieben, auf den Sie abzielen. Sie tun dies, indem Sie den Min-Wert hinzufügen.

Min + (Math.random() * (Max - Min))

Sie erhalten nun einen Wert im Bereich [Min,Max). Nach unserem Beispiel bedeutet das [5,10):

5 + (Math.random() * (10 - 5))

Dies ist jedoch immer noch nicht enthalten Maxund Sie erhalten einen doppelten Wert. Um den MaxWert aufzunehmen, müssen Sie Ihrem Bereichsparameter 1 hinzufügen (Max - Min)und dann den Dezimalteil abschneiden, indem Sie ihn in ein int umwandeln. Dies erfolgt über:

Min + (int)(Math.random() * ((Max - Min) + 1))

Und da hast du es. Ein zufälliger ganzzahliger Wert im Bereich [Min,Max]oder gemäß dem Beispiel [5,10]:

5 + (int)(Math.random() * ((10 - 5) + 1))

Verwenden:

Random ran = new Random();
int x = ran.nextInt(6) + 5;

Die Ganzzahl xist jetzt die Zufallszahl, deren Ergebnis möglicherweise ist 5-10.

Verwenden:

minimum + rn.nextInt(maxValue - minvalue + 1)

Mit Java-8Sie führten die Methode ints(int randomNumberOrigin, int randomNumberBound)in der RandomKlasse ein.

Wenn Sie beispielsweise fünf zufällige Ganzzahlen (oder eine einzelne) im Bereich [0, 10] generieren möchten, gehen Sie einfach wie folgt vor:

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

Der erste Parameter gibt nur die Größe des IntStreamgenerierten Parameters an (dies ist die überladene Methode derjenigen, die eine unbegrenzte erzeugt IntStream).

Wenn Sie mehrere separate Aufrufe ausführen müssen, können Sie aus dem Stream einen unendlichen primitiven Iterator erstellen:

public final class IntRandomNumberGenerator {

    private PrimitiveIterator.OfInt randomIterator;

    /**
     * Initialize a new random number generator that generates
     * random numbers in the range [min, max]
     * @param min - the min value (inclusive)
     * @param max - the max value (inclusive)
     */
    public IntRandomNumberGenerator(int min, int max) {
        randomIterator = new Random().ints(min, max + 1).iterator();
    }

    /**
     * Returns a random number in the range (min, max)
     * @return a random number in the range (min, max)
     */
    public int nextInt() {
        return randomIterator.nextInt();
    }
}

Sie können dies auch für doubleund longWerte tun . Ich hoffe, es hilft! :) :)

Sie können Ihr zweites Codebeispiel wie folgt bearbeiten:

Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;

Nur eine kleine Modifikation Ihrer ersten Lösung würde ausreichen.

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

Weitere Informationen zur Implementierung von finden Sie hier Random

ThreadLocalRandomÄquivalent der Klasse java.util.Randomfür eine Multithread-Umgebung. Das Generieren einer Zufallszahl erfolgt lokal in jedem der Threads. Wir haben also eine bessere Leistung, indem wir die Konflikte reduzieren.

int rand = ThreadLocalRandom.current().nextInt(x,y);

x, y- Intervalle zB (1,10)

Die Math.RandomKlasse in Java basiert auf 0. Also, wenn Sie so etwas schreiben:

Random rand = new Random();
int x = rand.nextInt(10);

x wird zwischen sein 0-9 inklusive sein.

Bei dem folgenden Array von 25Elementen lautet der Code zum Generieren einer Zufallszahl zwischen 0(der Basis des Arrays) und array.length:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

Da i.lengthwird zurückgegeben 25, nextInt( i.length )wird der eine Zahl zwischen dem Bereich von zurückgeben 0-24. Die andere Option Math.Randomfunktioniert genauso.

index = (int) Math.floor(Math.random() * i.length);

Weitere Informationen finden Sie im Forum-Beitrag Zufällige Intervalle (archive.org) .

Verzeihen Sie mir, dass ich anspruchsvoll bin, aber die von der Mehrheit vorgeschlagene Lösung, dh min + rng.nextInt(max - min + 1)), scheint gefährlich zu sein, weil:

• rng.nextInt(n)kann nicht erreichen Integer.MAX_VALUE.
• (max - min)kann einen Überlauf verursachen, wenn er minnegativ ist.

Eine narrensichere Lösung würde korrekte Ergebnisse für alle min <= maxinnerhalb von [ Integer.MIN_VALUE, Integer.MAX_VALUE] zurückgeben. Betrachten Sie die folgende naive Implementierung:

int nextIntInRange(int min, int max, Random rng) {
   if (min > max) {
      throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
   }
   int diff = max - min;
   if (diff >= 0 && diff != Integer.MAX_VALUE) {
      return (min + rng.nextInt(diff + 1));
   }
   int i;
   do {
      i = rng.nextInt();
   } while (i < min || i > max);
   return i;
}

Beachten Sie, dass die Erfolgswahrscheinlichkeit in der whileSchleife immer 50% oder mehr beträgt, obwohl sie ineffizient ist .

Dies kann durch einfaches Ausführen der folgenden Anweisung erfolgen:

Randomizer.generate(0,10); //min of zero, max of ten

Unten ist der Quellcode

Randomizer.java

public class Randomizer {
    public static int generate(int min,int max) {
        return min + (int)(Math.random() * ((max - min) + 1));
    }
}

Es ist einfach sauber und einfach.

Ich frage mich, ob eine der Zufallszahlengenerierungsmethoden, die von einer Apache Commons Math- Bibliothek bereitgestellt werden, in die Rechnung passt.

Zum Beispiel: RandomDataGenerator.nextIntoderRandomDataGenerator.nextLong

Nehmen wir ein Beispiel.

Angenommen, ich möchte eine Zahl zwischen 5 und 10 generieren :

int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);

Lassen Sie uns das verstehen ...

Initialisieren Sie max mit dem höchsten Wert und min mit dem niedrigsten Wert.

Nun müssen wir bestimmen, wie viele mögliche Werte erhalten werden können. Für dieses Beispiel wäre es:

5, 6, 7, 8, 9, 10

Die Anzahl wäre also max - min + 1.

dh 10 - 5 + 1 = 6

Die Zufallszahl erzeugt eine Zahl zwischen 0 und 5 .

dh 0, 1, 2, 3, 4, 5

Das Hinzufügen des Min- Werts zur Zufallszahl würde Folgendes ergeben:

5, 6, 7, 8, 9, 10

Somit erhalten wir den gewünschten Bereich.

 rand.nextInt((max+1) - min) + min;

Generieren Sie eine Zufallszahl für die Differenz von min und max mithilfe der nextint (n) -Methode und fügen Sie dann dem Ergebnis eine min-Zahl hinzu:

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

Ich benutze das:

 /**
   * @param min - The minimum.
   * @param max - The maximum.
   * @return A random double between these numbers (inclusive the minimum and maximum).
   */
 public static double getRandom(double min, double max) {
   return (Math.random() * (max + 1 - min)) + min;
 }

Sie können es in eine Ganzzahl umwandeln, wenn Sie möchten.

Ab Java 7 sollten Sie nicht mehr verwenden Random. Für die meisten Anwendungen ist jetzt der Zufallszahlengenerator der Wahl ThreadLocalRandom.

Verwenden Sie für Fork Join-Pools und parallele Streams SplittableRandom.

Joshua Bloch. Effektives Java. Dritte Edition.

Ab Java 8

Bei Fork-Join-Pools und parallelen Streams ist die Verwendung SplittableRandom, die normalerweise schneller ist, im Vergleich zu statistisch besser und einheitlicher Random.

Um einen Zufall intim Bereich zu generieren[0, 1_000]:

int n = new SplittableRandom().nextInt(0, 1_001);

So generieren Sie ein zufälliges int[100]Array von Werten im Bereich[0, 1_000]:

int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

So geben Sie einen Stream mit zufälligen Werten zurück:

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

Verwenden Sie einfach die Zufallsklasse :

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);

Diese Methoden sind möglicherweise bequem zu verwenden:

Diese Methode gibt eine Zufallszahl zwischen dem angegebenen Min- und Max-Wert zurück:

public static int getRandomNumberBetween(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt(max - min) + min;
    if (randomNumber == min) {
        // Since the random number is between the min and max values, simply add 1
        return min + 1;
    } else {
        return randomNumber;
    }
}

und diese Methode gibt eine Zufallszahl aus dem angegebenen Min- und Max-Wert zurück (die generierte Zahl kann also auch die Min- oder Max-Zahl sein):

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

Im Falle eines Würfelns wäre es eine Zufallszahl zwischen 1 und 6 (nicht 0 bis 6), also:

face = 1 + randomNumbers.nextInt(6);

int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

Oder werfen Sie einen Blick auf RandomUtils von Apache Commons .

Hier ist eine hilfreiche Klasse, um Zufallszahlen intsin einem Bereich mit einer beliebigen Kombination von Inklusiv- / Exklusivgrenzen zu generieren :

import java.util.Random;

public class RandomRange extends Random {
    public int nextIncInc(int min, int max) {
        return nextInt(max - min + 1) + min;
    }

    public int nextExcInc(int min, int max) {
        return nextInt(max - min) + 1 + min;
    }

    public int nextExcExc(int min, int max) {
        return nextInt(max - min - 1) + 1 + min;
    }

    public int nextIncExc(int min, int max) {
        return nextInt(max - min) + min;
    }
}

Verwenden Sie den folgenden Code, um eine Zufallszahl "zwischen zwei Zahlen" zu generieren:

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

Dies gibt Ihnen eine Zufallszahl zwischen 1 (einschließlich) und 11 (exklusiv). Initialisieren Sie also den UpperBound-Wert durch Hinzufügen von 1. Wenn Sie beispielsweise eine Zufallszahl zwischen 1 und 10 generieren möchten, initialisieren Sie die UpperBound-Zahl mit 11 anstelle von 11 10.

Sie können dies in Java 8 präzise erreichen:

Random random = new Random();

int max = 10;
int min = 5;
int totalNumber = 10;

IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);

public static Random RANDOM = new Random(System.nanoTime());

public static final float random(final float pMin, final float pMax) {
    return pMin + RANDOM.nextFloat() * (pMax - pMin);
}

Eine andere Option ist nur die Verwendung von Apache Commons :

import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;

public void method() {
    RandomData randomData = new RandomDataImpl();
    int number = randomData.nextInt(5, 10);
    // ...
 }

Ich habe dieses Beispiel gefunden. Zufallszahlen generieren :

In diesem Beispiel werden zufällige Ganzzahlen in einem bestimmten Bereich generiert.

import java.util.Random;

/** Generate random integers in a certain range. */
public final class RandomRange {

  public static final void main(String... aArgs){
    log("Generating random integers in the range 1..10.");

    int START = 1;
    int END = 10;
    Random random = new Random();
    for (int idx = 1; idx <= 10; ++idx){
      showRandomInteger(START, END, random);
    }

    log("Done.");
  }

  private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
    if ( aStart > aEnd ) {
      throw new IllegalArgumentException("Start cannot exceed End.");
    }
    //get the range, casting to long to avoid overflow problems
    long range = (long)aEnd - (long)aStart + 1;
    // compute a fraction of the range, 0 <= frac < range
    long fraction = (long)(range * aRandom.nextDouble());
    int randomNumber =  (int)(fraction + aStart);    
    log("Generated : " + randomNumber);
  }

  private static void log(String aMessage){
    System.out.println(aMessage);
  }
} 

Ein Beispiellauf dieser Klasse:

Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.

Es ist besser, SecureRandom als nur Random zu verwenden.

public static int generateRandomInteger(int min, int max) {
    SecureRandom rand = new SecureRandom();
    rand.setSeed(new Date().getTime());
    int randomNum = rand.nextInt((max - min) + 1) + min;
    return randomNum;
}

Hier ist ein einfaches Beispiel, das zeigt, wie Zufallszahlen aus dem geschlossenen [min, max]Bereich generiert werdenmin <= max is true

Sie können es als Feld in der Lochklasse wiederverwenden und alle Random.classMethoden an einem Ort haben

Ergebnisbeispiel:

RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert

Quellen:

import junit.framework.Assert;
import java.util.Random;

public class RandomUtils extends Random {

    /**
     * @param min generated value. Can't be > then max
     * @param max generated value
     * @return values in closed range [min, max].
     */
    public int nextInt(int min, int max) {
        Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
        if (min == max) {
            return max;
        }

        return nextInt(max - min + 1) + min;
    }
}

rand.nextInt((max+1) - min) + min;

Das funktioniert gut.