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

Ich werde einfach angeben, was an den Lösungen der Frage falsch ist und warum die Fehler.

Lösung 1:

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

Problem: randomNum werden Werte zugewiesen, die größer als das Maximum sind.

Erläuterung: Angenommen, unser Minimum ist 5 und Ihr Maximum ist 10. Jeder Wert von Math.random() größer als 0,6 führt dazu, dass der Ausdruck 6 oder mehr ergibt, und durch Hinzufügen von 5 wird er größer als 10 (Ihr Maximum). Das Problem ist, dass Sie die Zufallszahl mit dem Maximum multiplizieren (was eine Zahl ergibt, die fast so groß ist wie das Maximum) und dann das Minimum addieren. Wenn das Minimum nicht 1 ist, ist es nicht korrekt. Sie müssen, wie in anderen Antworten erwähnt, umschalten auf

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

Das +1 liegt daran, dass Math.random() wird niemals 1,0 zurückgeben.

Lösung 2:

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

Ihr Problem ist, dass '%' eine negative Zahl zurückgeben kann, wenn der erste Term kleiner als 0 ist. rn.nextInt() mit einer Wahrscheinlichkeit von ~50 % negative Werte liefert, werden Sie auch nicht das erwartete Ergebnis erhalten.

Diese war jedoch nahezu perfekt. Man musste nur ein bisschen weiter unten in der Javadoc nachsehen, nextInt(int n) . Mit dieser Methode ist es möglich, die

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

würde ebenfalls das gewünschte Ergebnis liefern.

Answer 2

Sie können dieses Codeschnipsel verwenden, um Ihr Problem zu lösen:

Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;

Verwenden Sie myRandomNumber (das Ihnen eine Zahl innerhalb eines Bereichs liefert).

Answer 3

Ein anderer Ansatz mit Java 8 IntStream und Collections.shuffle

import java.util.stream.IntStream;
import java.util.ArrayList;
import java.util.Collections;

public class Main {

    public static void main(String[] args) {

        IntStream range = IntStream.rangeClosed(5,10);
        ArrayList<Integer> ls =  new ArrayList<Integer>();

        //populate the ArrayList
        range.forEach(i -> ls.add(new Integer(i)) );

        //perform a random shuffle  using the Collections Fisher-Yates shuffle
        Collections.shuffle(ls);
        System.out.println(ls);
    }
}

Die Entsprechung in Scala

import scala.util.Random

object RandomRange extends App{
  val x =  Random.shuffle(5 to 10)
    println(x)
}

Answer 4

import java.util.Random; 

public class RandomUtil {
    // Declare as class variable so that it is not re-seeded every call
    private static Random random = new Random();

    /**
     * Returns a psuedo-random number between min and max (both inclusive)
     * @param min Minimim value
     * @param max Maximim value. Must be greater than min.
     * @return Integer between min and max (both inclusive)
     * @see java.util.Random#nextInt(int)
     */
    public static int nextInt(int min, int max) {
        // nextInt is normally exclusive of the top value,
        // so add 1 to make it inclusive
        return random.nextInt((max - min) + 1) + min;
    }
}

Answer 5

Der folgende Code könnte verwendet werden:

ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)