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

Question

Wie generiere ich eine zufällige int Wert in einem bestimmten Bereich?

Ich habe Folgendes versucht, aber das funktioniert nicht:

Versuch 1:

randomNum = minimum + (int)(Math.random() * maximum);

Fehler: randomNum kann größer sein als maximum .

Versuch 2:

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

Fehler: randomNum kann kleiner sein als minimum .

Answer 1

Mit Java 17 wurde die RandomGenerator Schnittstelle, die eine int nextInt(int origin, int bound) Methode, um eine zufällige Ganzzahl in einem Bereich zu erhalten:

// Returns a random int between minimum (inclusive) & maximum (exclusive)
int randomInt = RandomGenerator.getDefault().nextInt(minimum, maximum);

Diese Schnittstelle wird nicht nur für die neuen Zufallsgenerierungsalgorithmen in Java 17 verwendet, sondern wurde auch zu den bestehenden Zufallsgenerierungsklassen hinzugefügt ( Random , SecureRandom , SplittableRandom und ThreadLocalRandom ). Daher haben diese Klassen ab Java 17 diese begrenzte nextInt Methode:

new Random().nextInt(minimum, maximum);
new SecureRandom().nextInt(minimum, maximum);
new SplittableRandom().nextInt(minimum, maximum);
new ThreadLocalRandom().nextInt(minimum, maximum);

Diese Methode ist neu für Random y SecureRandom ab Java 17. Vor Java 17, ThreadLocalRandom y SplittableRandom verfügte bereits über diese Methode, obwohl sie nicht durch eine gemeinsame Schnittstelle spezifiziert war.

Answer 2

Ich habe dieses Beispiel gefunden Zufallszahlen generieren :

---

Dieses Beispiel erzeugt zufällige Ganzzahlen in einem bestimmten Bereich.

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.

Answer 3

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);
}

Answer 4

Hier ist ein einfaches Beispiel, das zeigt, wie man eine Zufallszahl aus einer geschlossenen [min, max] Bereich, während min <= max is true

Sie können es als Feld in der gesamten Klasse wiederverwenden, wobei auch alle Random.class Methoden an einem Ort

Beispiel für Ergebnisse:

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;
    }
}

Answer 5

Es ist besser, die SecureRandom und nicht nur zufällig.

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;
}