Come posso generare numeri interi casuali all'interno di un intervallo specifico in Java?

Come posso generare un intvalore casuale in un intervallo specifico?

Ho provato quanto segue, ma quelli non funzionano:

Tentativo 1:

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

Tentativo 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 o versioni successive , il modo standard per farlo è il seguente:

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

Vedi il JavaDoc pertinente . Questo approccio ha il vantaggio di non dover inizializzare esplicitamente un'istanza java.util.Random , che può essere fonte di confusione ed errore se utilizzata in modo inappropriato.

Tuttavia, al contrario, non c'è modo di impostare esplicitamente il seme, quindi può essere difficile riprodurre i risultati in situazioni in cui ciò è utile come testare o salvare stati di gioco o simili. In tali situazioni, è possibile utilizzare la tecnica pre-Java 1.7 illustrata di seguito.

Prima di Java 1.7 , il modo standard per farlo è il seguente:

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

Vedi il JavaDoc pertinente . In pratica, la classe java.util.Random è spesso preferibile a java.lang.Math.random () .

In particolare, non è necessario reinventare la ruota di generazione di numeri interi casuali quando è presente un'API semplice all'interno della libreria standard per eseguire l'attività.

Si noti che questo approccio è più distorto e meno efficiente di un nextIntapproccio, https://stackoverflow.com/a/738651/360211

Un modello standard per raggiungere questo obiettivo è:

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

La Java funzione di libreria Math Math.random () genera un doppio valore nell'intervallo [0,1). Si noti che questo intervallo non include l'1.

Per ottenere prima un intervallo di valori specifico, è necessario moltiplicare per l'entità dell'intervallo di valori che si desidera coprire.

Math.random() * ( Max - Min )

Ciò restituisce un valore nell'intervallo [0,Max-Min), dove "Max-Min" non è incluso.

Ad esempio, se si desidera [5,10), è necessario coprire cinque valori interi in modo da utilizzare

Math.random() * 5

Ciò restituirebbe un valore nell'intervallo [0,5), dove 5 non è incluso.

Ora devi spostare questo intervallo fino all'intervallo a cui ti rivolgi. Puoi farlo aggiungendo il valore Min.

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

Ora otterrai un valore nell'intervallo [Min,Max). Seguendo il nostro esempio, ciò significa [5,10):

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

Ma questo non include ancora Maxe stai ottenendo un doppio valore. Per ottenere il Maxvalore incluso, è necessario aggiungere 1 al parametro range (Max - Min)e quindi troncare la parte decimale eseguendo il casting in un int. Questo si ottiene tramite:

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

E il gioco è fatto. Un valore intero casuale nell'intervallo [Min,Max]o per l'esempio [5,10]:

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

Uso:

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

L'intero xè ora il numero casuale che ha un possibile risultato di 5-10.

Uso:

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

Con java-8hanno introdotto il metodo ints(int randomNumberOrigin, int randomNumberBound)nella Randomclasse.

Ad esempio, se vuoi generare cinque numeri interi casuali (o uno singolo) nell'intervallo [0, 10], fai semplicemente:

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

Il primo parametro indica solo la dimensione del IntStreamgenerato (che è il metodo sovraccarico di quello che produce un numero illimitato IntStream).

Se è necessario eseguire più chiamate separate, è possibile creare un iteratore primitivo infinito dallo stream:

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

Puoi anche farlo per doublee longvalori. Spero possa essere d'aiuto! :)

Puoi modificare il tuo secondo esempio di codice per:

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

Basta una piccola modifica della tua prima soluzione.

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

Vedi di più qui per l'implementazione di Random

ThreadLocalRandomequivalente di classe java.util.Randomper ambiente multithread. La generazione di un numero casuale viene eseguita localmente in ciascuno dei thread. Quindi abbiamo prestazioni migliori riducendo i conflitti.

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

x, y- intervalli ad es. (1,10)

La Math.Randomclasse in Java è basata su 0. Quindi, se scrivi qualcosa del genere:

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

xsarà compreso 0-9compreso.

Quindi, dato il seguente array di 25elementi, il codice per generare un numero casuale tra 0(la base dell'array) e array.lengthsarebbe:

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

index = rand.nextInt( i.length );

Poiché i.lengthrestituirà 25, nextInt( i.length )restituirà un numero compreso nell'intervallo di 0-24. L'altra opzione è Math.Randomche funziona allo stesso modo.

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

Per una migliore comprensione, dai un'occhiata al post sul forum Intervalli casuali (archive.org) .

Perdonatemi per essere pignolo, ma la soluzione suggerita dalla maggioranza, vale a dire min + rng.nextInt(max - min + 1)), sembra pericolosa a causa del fatto che:

• rng.nextInt(n)impossibile raggiungere Integer.MAX_VALUE.
• (max - min)può causare overflow quando minè negativo.

Una soluzione infallibile restituirebbe risultati corretti per qualsiasi valore min <= maxcompreso tra [ Integer.MIN_VALUE, Integer.MAX_VALUE]. Considera la seguente ingenua implementazione:

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

Sebbene inefficiente, nota che la probabilità di successo nel whileloop sarà sempre del 50% o superiore.

Può essere fatto semplicemente facendo la dichiarazione:

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

Di seguito è riportato il suo codice sorgente

Randomizer.java

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

È semplicemente pulito e semplice.

Mi chiedo se uno qualsiasi dei metodi di generazione di numeri casuali forniti da una biblioteca di matematica di Apache Commons si adatterebbe al conto.

Ad esempio: RandomDataGenerator.nextIntoRandomDataGenerator.nextLong

Facciamo un esempio.

Supponiamo di voler generare un numero tra 5-10 :

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

Cerchiamo di capire questo ...

Inizializza max con il valore più alto e min con il valore più basso.

Ora, dobbiamo determinare quanti possibili valori possono essere ottenuti. Per questo esempio, sarebbe:

5, 6, 7, 8, 9, 10

Quindi, conta di questo sarebbe max - min + 1.

cioè 10-5 + 1 = 6

Il numero casuale genererà un numero compreso tra 0-5 .

cioè 0, 1, 2, 3, 4, 5

L'aggiunta del valore minimo al numero casuale produrrebbe:

5, 6, 7, 8, 9, 10

Quindi otteniamo l'intervallo desiderato.

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

Generare un numero casuale per la differenza di min e max utilizzando il metodo nextint (n) e quindi aggiungere un numero minimo al risultato:

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

Io lo uso questo:

 /**
   * @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;
 }

Puoi lanciarlo su un numero intero se vuoi.

A partire da Java 7, non dovresti più usare Random. Per la maggior parte degli usi, il generatore di numeri casuali di scelta è ora ThreadLocalRandom.

Per pool di join fork e flussi paralleli, utilizzare SplittableRandom.

Joshua Bloch. Java efficace. Terza edizione.

A partire da Java 8

Per i pool di join fork e i flussi paralleli, l'utilizzo SplittableRandomè solitamente più veloce, rispetto a una migliore indipendenza statistica e proprietà di uniformità Random.

Per generare un casuale intnell'intervallo[0, 1_000]:

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

Per generare una int[100]matrice casuale di valori nell'intervallo[0, 1_000]:

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

Per restituire un flusso di valori casuali:

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

Basta usare la classe casuale :

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

Questo metodo potrebbe essere comodo da usare:

Questo metodo restituirà un numero casuale tra il valore minimo e massimo fornito:

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

e questo metodo restituirà un numero casuale dal valore minimo e massimo fornito (quindi il numero generato potrebbe essere anche il numero minimo o massimo):

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

    return randomNumber;
}

In caso di lancio di un dado sarebbe un numero casuale compreso tra 1 e 6 (non tra 0 e 6), quindi:

face = 1 + randomNumbers.nextInt(6);

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

O dai un'occhiata a RandomUtils da Apache Commons .

Ecco una classe utile per generare random intsin un intervallo con qualsiasi combinazione di limiti inclusivi / esclusivi:

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

Per generare un numero casuale "tra due numeri", utilizzare il seguente codice:

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

Questo ti dà un numero casuale compreso tra 1 (incluso) e 11 (esclusivo), quindi inizializza il valore upperBound aggiungendo 1. Ad esempio, se desideri generare un numero casuale compreso tra 1 e 10, inizializza il numero upperBound con 11 anziché 10.

Puoi farlo concisamente in Java 8:

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

Un'altra opzione è solo usando 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);
    // ...
 }

Ho trovato questo esempio Genera numeri casuali :

Questo esempio genera numeri interi casuali in un intervallo specifico.

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

Un esempio di questa classe:

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.

È meglio usare SecureRandom piuttosto che solo Random.

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

Ecco un semplice esempio che mostra come generare un numero casuale da un [min, max]intervallo chiuso , mentremin <= max is true

Puoi riutilizzarlo come campo nella classe del foro, avendo anche tutti i Random.classmetodi in un unico posto

Esempio di risultati:

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

fonti:

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;

Funziona benissimo.