¿Cómo genero números enteros aleatorios dentro de un rango específico en Java?

In Java 1.7 o posterior, la forma estándar de hacerlo es la siguiente:

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

Ver el JavaDoc relevante. Este enfoque tiene la ventaja de no necesitar inicializar explícitamente un java.util.Random ejemplo, que puede ser una fuente de confusión y error si se usa de manera inapropiada.

Sin embargo, a la inversa, no hay forma de establecer explícitamente la semilla, por lo que puede ser difícil reproducir resultados en situaciones en las que sea útil, como probar o guardar estados del juego o similar. En esas situaciones, se puede utilizar la técnica anterior a Java 1.7 que se muestra a continuación.

Antes de Java 1.7, la forma estándar de hacerlo es la siguiente:

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

Ver el JavaDoc relevante. En la práctica, el java.util.Random la clase es a menudo preferible a java.lang.Math.random ().

En particular, no es necesario reinventar la rueda de generación de enteros aleatorios cuando hay una API sencilla dentro de la biblioteca estándar para realizar la tarea.

Tenga en cuenta que este enfoque es más sesgado y menos eficiente que un nextInt Acercarse, https://stackoverflow.com/a/738651/360211

Un patrón estándar para lograr esto es:

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

EL Java La función de biblioteca matemática Math.random () genera un valor doble en el rango [0,1). Tenga en cuenta que este rango no incluye el 1.

Para obtener primero un rango específico de valores, debe multiplicar por la magnitud del rango de valores que desea cubrir.

Math.random() * ( Max - Min )

Esto devuelve un valor en el rango [0,Max-Min), donde 'Max-Min' no está incluido.

Por ejemplo, si quieres [5,10), debe cubrir cinco valores enteros para usar

Math.random() * 5

Esto devolvería un valor en el rango [0,5), donde 5 no está incluido.

Ahora debe cambiar este rango al rango al que se dirige. Haz esto agregando el valor mínimo.

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

Ahora obtendrá un valor en el rango [Min,Max). Siguiendo nuestro ejemplo, eso significa [5,10):

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

Pero, esto todavía no incluye Max y obtiene un valor doble. Para obtener el Max valor incluido, debe agregar 1 a su parámetro de rango (Max - Min) y luego truncar la parte decimal convirtiendo a un int. Esto se logra a través de:

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

Y ahí lo tienes. Un valor entero aleatorio en el rango [Min,Max], o por el ejemplo [5,10]:

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

Uso:

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

El entero x es ahora el número aleatorio que tiene un posible resultado de 5-10.

Uso:

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

Con java-8 introdujeron el método ints(int randomNumberOrigin, int randomNumberBound) en el capítulo respecto a la Random clase.

Por ejemplo, si desea generar cinco números enteros aleatorios (o uno solo) en el rango [0, 10], simplemente haga:

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

El primer parámetro indica solo el tamaño del IntStream generado (que es el método sobrecargado del que produce un ilimitado IntStream).

Si necesita hacer varias llamadas por separado, puede crear un iterador primitivo infinito a partir de la secuencia:

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

También puedes hacerlo por double y long valores. ¡Espero que ayude! :)

Puede editar su segundo ejemplo de código para:

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

Bastaría con una pequeña modificación de su primera solución.

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

Vea más aquí para la implementación de Random

ThreadLocalRandom equivalente de clase java.util.Random para entornos multiproceso. La generación de un número aleatorio se realiza de forma local en cada uno de los hilos. Entonces tenemos un mejor desempeño al reducir los conflictos.

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

x,y - intervalos, por ejemplo (1,10)

EL Math.Random clase en Java está basado en 0. Entonces, si escribe algo como esto:

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

x estará entre 0-9 inclusivo.

Entonces, dada la siguiente matriz de 25 elementos, el código para generar un número aleatorio entre 0 (la base de la matriz) y array.length sería:

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

index = rand.nextInt( i.length );

Como i.length regresará 25, la nextInt( i.length ) devolverá un número entre el rango de 0-24. La otra opción va con Math.Random que funciona de la misma manera.

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

Para una mejor comprensión, consulte la publicación del foro. Intervalos aleatorios (archive.org).

Se puede hacer simplemente haciendo la declaración:

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

A continuación se muestra su código fuente

Aleatorizador.java

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

Es simple y limpio.

Perdóname por ser fastidioso, pero la solución sugerida por la mayoría, es decir, min + rng.nextInt(max - min + 1)), parece peligroso debido al hecho de que:

• rng.nextInt(n) no puedo alcanzar Integer.MAX_VALUE.
• (max - min) puede causar desbordamiento cuando min es negativo

Una solución infalible devolvería resultados correctos para cualquier min <= max dentro [Integer.MIN_VALUE, Integer.MAX_VALUE]. Considere la siguiente implementación ingenua:

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

Aunque ineficiente, tenga en cuenta que la probabilidad de éxito en el while El bucle siempre será del 50% o más.

Me pregunto si alguno de los métodos de generación de números aleatorios proporcionados por un Matemáticas de Apache Commons biblioteca encajaría a la perfección.

Por ejemplo: RandomDataGenerator.nextInt or RandomDataGenerator.nextLong

Tomemos un ejemplo.

Supongamos que deseo generar un número entre 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);

Entendamos esto...

Inicialice max con el valor más alto y min con el valor más bajo.

Ahora, necesitamos determinar cuántos valores posibles se pueden obtener. Para este ejemplo, sería:

5, 6, 7, 8, 9, 10

Entonces, el recuento de esto sería máximo - mínimo + 1.

es decir, 10-5 + 1 = 6

El número aleatorio generará un número entre 0-5.

es decir, 0, 1, 2, 3, 4, 5

Añadiendo el min valor al número aleatorio produciría:

5, 6, 7, 8, 9, 10

De ahí obtenemos el rango deseado.

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

Yo uso esto:

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

Puede convertirlo en un entero si lo desea.

Genere un número aleatorio para la diferencia de mínimo y máximo usando el nextint (n) método y luego agregue el número mínimo al resultado:

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

A partir de Java 7, ya no debería utilizar Random. Para la mayoría de los usos, el generador de números aleatorios elegido ahora es ThreadLocalRandom.

Para grupos de unión en bifurcación y corrientes paralelas, utilice SplittableRandom.

Joshua Bloch. Java eficaz. Tercera edicion.

Comenzando desde Java 8

Para grupos de unión en bifurcación y corrientes paralelas, utilice SplittableRandom que suele ser más rápido, tiene una mejor independencia estadística y propiedades de uniformidad en comparación con Random.

Para generar un aleatorio int en el rango [0, 1_000]:

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

Para generar un aleatorio int[100] matriz de valores en el rango [0, 1_000]:

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

Para devolver una secuencia de valores aleatorios:

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

Para generar un número aleatorio "entre dos números", utilice el siguiente código:

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

Esto le da un número aleatorio entre 1 (incluido) y 11 (exclusivo), así que inicialice el valor de límite superior agregando 1. Por ejemplo, si desea generar un número aleatorio entre 1 y 10, inicialice el número de límite superior con 11 en lugar de 10.

Solo usa el Aleatorio clase:

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

Estos métodos pueden ser convenientes de usar:

Este método devolverá un número aleatorio entre el valor mínimo y máximo proporcionado:

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

y este método devolverá un número aleatorio a partir de octubre XNUMX el valor mínimo y máximo proporcionado (por lo que el número generado también podría ser el número mínimo o máximo):

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

    return randomNumber;
}

En caso de lanzar un dado, sería un número aleatorio entre 1 y 6 (no entre 0 y 6), así que:

face = 1 + randomNumbers.nextInt(6);

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

O eche un vistazo a RandomUtils desde Apache Commons.

Aquí hay una clase útil para generar aleatoriamente ints en un rango con cualquier combinación de límites inclusivos / exclusivos:

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

Puede lograr eso de manera concisa en 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);
}

Otra opción es simplemente usar 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);
    // ...
 }

Encontré este ejemplo Genera números aleatorios :

Este ejemplo genera números enteros aleatorios en un rango específico.

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 ejemplo de ejecución de esta clase:

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 mejor usar SeguroAleatorio en lugar de solo aleatorio.

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

Aquí hay una muestra simple que muestra cómo generar un número aleatorio a partir de [min, max] rango, mientras min <= max is true

Puede reutilizarlo como campo en la clase de agujero, teniendo también todos Random.class métodos en un solo lugar

Ejemplo de resultados:

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

Fuentes:

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;

Esto está funcionando bien.