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

3785

¿Cómo genero un intvalor aleatorio en un rango específico?

He intentado lo siguiente, pero no funcionan:

Intento 1:

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

Error: randomNumpuede ser más grande que maximum.

Intento 2:

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

Error: randomNumpuede ser más pequeño que minimum.

2
  • Cuando necesita muchos números aleatorios, no recomiendo la clase Random en la API. Tiene un período demasiado pequeño. En su lugar, prueba el tornado de Mersenne . Hay una implementación de Java .
    raupach
    13 de diciembre de 2008 a las 10:18
  • 20
    Antes de publicar una nueva respuesta, considere que ya hay más de 65 respuestas para esta pregunta. Por favor, asegúrese de que su respuesta aporte información que no se encuentre entre las respuestas existentes.
    janniks
    3 feb.20 a las 11:53
4066
+150

En Java 1.7 o posterior , la forma estándar de hacer esto 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);

Consulte el archivo JavaDoc correspondiente . Este enfoque tiene la ventaja de no necesitar inicializar explícitamente una instancia java.util.Random , 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 de 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 hacer esto 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;
}

Consulte el archivo JavaDoc correspondiente . En la práctica, la clase java.util.Random suele ser 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.

14
  • 47
    Para las llamadas en las que el maxvalor es Integer.MAX_VALUE, es posible que se desborde, lo que da como resultado un java.lang.IllegalArgumentException. Usted puede tratar con: randInt(0, Integer.MAX_VALUE). Además, si nextInt((max-min) + 1)devuelve el valor más alto (bastante raro, supongo), ¿no se desbordará nuevamente (suponiendo que el mínimo y el máximo son valores lo suficientemente altos)? ¿Cómo afrontar este tipo de situaciones?
    Daniel
    12 de agosto de 2014 a las 10:34
  • 14
    @leventov ThreadLocalRandomse agregó a Java 2 1/2 años después de que se formulara esta pregunta por primera vez. Siempre he tenido la firme opinión de que la gestión de la instancia Random está fuera del alcance de la pregunta. 11 de septiembre de 2015 a las 1:57
  • 6
    En Android Random rand = new Random (); 3 oct 2016 a las 19:55
  • 6
    @Webserveis Esto se aborda en los comentarios del ejemplo. Versión corta: no debe = new Random () para cada llamada a la función, o sus resultados no serán lo suficientemente aleatorios en muchos casos. 4 oct 2016 a las 0:29
  • 5
    @ChitKhine No en cada llamada a la función. El algoritmo RNG bajo el capó de Random funciona bien (lo suficiente para aplicaciones no criptográficas) al generar números aleatorios sucesivos. Sin embargo, si la instancia Random se vuelve a crear en cada llamada, eso significa que en lugar de un RNG adecuado, obtendrá números "aleatorios" basados ​​en cualquier semilla que se elija cada vez; a menudo, esto se basa en el reloj del sistema. Esto puede dar resultados decididamente no aleatorios. En su lugar, debería considerar crear una instancia de su instancia aleatoria fuera del alcance del método. El código de ejemplo intenta solucionar este problema. 13 de marzo de 2017 a las 3:09
1475

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

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

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

La función de la biblioteca Java Math 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 no se incluye 'Max-Min'.

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

Math.random() * 5

Esto devolvería un valor en el rango [0,5), donde no se incluye 5.

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 Maxy está obteniendo un valor doble. Para obtener el Maxvalor incluido, debe agregar 1 a su parámetro de rango (Max - Min)y luego truncar la parte decimal al convertir 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 ejemplo [5,10]:

5 + (int)(Math.random() * ((10 - 5) + 1))
4
  • 87
    La documentación de Sun dice explícitamente que es mejor usar Random () si necesita un int en lugar de Math.random () que produce un doble. 23/02/12 a las 23:26
  • 6
    En realidad, esto está sesgado en comparación con los métodos nextInt stackoverflow.com/a/738651/360211
    weston
    29/12/2016 a las 13:35
  • 6
    En este caso, "sesgado" significa que después de 2 ^ 53 ejecuciones, algunos números habrán tenido una ocurrencia adicional, en promedio. 29/08/19 a las 9:48
  • Aunque también use esto, quiero señalar que este no es un verdadero número aleatorio. Es por eso que no debe usarse para ninguna funcionalidad de seguridad. Pero para cualquier caso casual, es el método más directo.
    Tobias
    20/10/20 a las 13:28
413

Usar:

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

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

0
183

Usar:

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

Con introdujeron el método ints(int randomNumberOrigin, int randomNumberBound)en la Randomclase.

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 IntStreamgenerado (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 doubley longvalores. ¡Espero que ayude! :)

1
  • 3
    Sugeriría que cree una instancia de randomIterator solo una vez. Vea el comentario de Greg Case sobre su propia respuesta.
    Naxos84
    26/02/18 a las 7:13
116

Puede editar su segundo ejemplo de código para:

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

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

3
  • Para mínimo <= valor <máximo, hice lo mismo con Math: randomNum = mínimo + (int) (Math.random () * (máximo-mínimo)); pero el casting no es muy agradable de ver;)
    AxelH
    8 de julio de 2016 a las 12:30
  • Al menos 7 años de retraso en la respuesta duplicada. 5 de mayo de 2020 a las 19:55
  • Ese fue el más fácil de implementar para mí como principiante. ¡Gracias! 9 de marzo a las 12:58
90

ThreadLocalRandomequivalente de clase java.util.Randompara 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 p. ej. (1,10)

0
74

La Math.Randomclase en Java está basada en 0. Entonces, si escribe algo como esto:

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

xestará entre 0-9inclusive.

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

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

index = rand.nextInt( i.length );

Dado i.lengthque volverá 25, nextInt( i.length )devolverá un número entre el rango de 0-24. La otra opción es ir con la Math.Randomque funciona de la misma forma.

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

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

5
  • +1 para el enlace de captura de pantalla del archivo wayBackMachine y su respuesta sigue siendo una referencia útil para obtener entradas "aleatorias" dentro de un rango.
    Tapper7
    30/10/2016 a las 5:44
  • Me desconcierta por qué crea una instancia del índice en 0. 2 de agosto de 2017 a las 13:53
  • @CodeConfident La indexvariable no afectará el resultado del número aleatorio. Puede optar por inicializarlo de la forma que desee sin tener que preocuparse por cambiar el resultado. Espero que esto ayude.
    Matt R
    2 de agosto de 2017 a las 14:38
  • Exactamente ... está completamente sin usar. Lo inicializaría directamente en el rand:int index = rand.nextInt(i.Length); 2 de agosto de 2017 a las 14:41
  • O no del todo. int index; \n index = rand...si le gustan las declaraciones y asignaciones en diferentes líneas. Algunos estándares de codificación son más estrictos (y sin un propósito aparente) que otros. 17/09/19 a las 18:24
54

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

Randomizer.java

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

Es simple y limpio.

3
  • 5
    Esto podría haber sido una edición del otro ejemplo, ahora es solo una copia descarada para la reputación. Señalar la "respuesta con más votos" tampoco es muy directo, puede cambiar. 19/06/2017 a las 21:23
  • 1
    Eso es correcto @MaartenBodewes. Cuando escribí esta respuesta, la respuesta con más votos arriba todavía estaba escrita como una solución similar a un algoritmo. Ahora, la solución anterior ha cambiado mucho y ahora esta respuesta parecía una imitación. 20 de junio de 2017 a las 0:36
  • Realmente no entiendo por qué esos bits fundamentales de código no forman parte de las bibliotecas estándar de Java. ¿Por qué tengo que implementar esto?
    Leevi L
    8/10/19 a las 8:31
50

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

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

Una solución infalible devolvería resultados correctos para cualquier min <= maxdentro de [ 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 es ineficiente, tenga en cuenta que la probabilidad de éxito en el whileciclo siempre será del 50% o más.

2
  • ¿Por qué no lanzar una IllegalArgumentException cuando la diferencia = Integer.MAX_VALUE? Entonces no necesitas el bucle while. 9 de enero de 2015 a las 10:27
  • 3
    @mpkorstanje Esta implementación está diseñada para trabajar con cualquier valor de min <= max, incluso cuando su diferencia es igual o incluso mayor que MAX_VALUE. Ejecutar un ciclo hasta el éxito es un patrón común en este caso, para garantizar una distribución uniforme (si la fuente subyacente de aleatoriedad es uniforme). Random.nextInt (int) lo hace internamente cuando el argumento no es una potencia de 2. 6 de mayo de 2015 a las 19:27
34

Me pregunto si alguno de los métodos de generación de números aleatorios proporcionados por una biblioteca de Apache Commons Math encajaría bien.

Por ejemplo: RandomDataGenerator.nextIntoRandomDataGenerator.nextLong

0
34

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.

3
  • Esta función produce el mismo número una y otra vez. En mi caso fue: 2147483647
    sokras
    20/07/2017 a las 7:38
  • Fallar: ¿tienes una función que requiere un doble y luego realizar + 1? Ciertamente, esto va en contra del principio de la mínima sorpresa. ¿Qué sucede si usa min = 0.1 y max = 0.2? 23/04/18 a las 21:26
  • @sokras el método llama new Random(verifique el JavaDoc): "Crea un nuevo generador de números aleatorios. Este constructor establece la semilla del generador de números aleatorios en un valor muy probablemente distinto de cualquier otra invocación de este constructor". Es muy probable que solo implique el uso de la hora actual como semilla. Si ese tiempo usa milisegundos, las computadoras actuales son lo suficientemente rápidas para generar el mismo número. Pero además de eso es 2147483647 Integer.MAX_VALUE; la salida obviamente depende de la entrada, que no ha especificado. 23/04/18 a las 21:36
31

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 ...

Initialize max with highest value and min with the lowest value.

Now, we need to determine how many possible values can be obtained. For this example, it would be:

5, 6, 7, 8, 9, 10

So, count of this would be max - min + 1.

i.e. 10 - 5 + 1 = 6

The random number will generate a number between 0-5.

i.e. 0, 1, 2, 3, 4, 5

Adding the min value to the random number would produce:

5, 6, 7, 8, 9, 10

Hence we obtain the desired range.

30
 rand.nextInt((max+1) - min) + min;
0
27

As of Java 7, you should no longer use Random. For most uses, the random number generator of choice is now ThreadLocalRandom.

For fork join pools and parallel streams, use SplittableRandom.

Joshua Bloch. Java eficaz. Tercera edicion.

Comenzando desde Java 8

Para grupos de unión en bifurcación y flujos paralelos, el uso SplittableRandomsuele ser más rápido, tiene una mejor independencia estadística y propiedades de uniformidad en comparación con Random.

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

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

Para generar una int[100]matriz aleatoria 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);
2
  • ¿Hay alguna razón por la que el ejemplo incluya un .parallel()? Me parece que generar 100 números aleatorios sería demasiado trivial para garantizar el paralelismo.
    Johnbot
    20 de julio de 2018 a las 6:29
  • @Johnbot Gracias por comentar, tienes razón. Pero, la razón principal fue mostrar una API (por supuesto, la ruta inteligente es medir el rendimiento antes de usar el parallelprocesamiento). Por cierto, para la matriz de 1_000_000elementos, la parallelversión fue 2 veces más rápida en mi máquina en comparación con la secuencial. 20 de julio de 2018 a las 8:35
27

Genere un número aleatorio para la diferencia de mínimo y máximo utilizando el método nextint (n) 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);
0
22

Solo usa la clase Random :

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
3
  • 9
    No veo nada nuevo aquí que no se haya publicado en innumerables publicaciones anteriores. 19/06/2017 a las 21:21
  • @MaartenBodewes Esas innumerables publicaciones son difíciles de encontrar. Algunos otros métodos en la parte superior 26 de marzo a las 20:22
  • Sí, publicar otro engaño no va a ayudar contra eso. Vote las otras respuestas o agregue detalles. De lo contrario, es solo cultivo de representantes. 26 de marzo a las 20:31
21

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 (inclusive) 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.

20

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 del 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;
}
3
  • // Since the random number is between the min and max values, simply add 1. ¿Por qué? ¿No cuenta el mínimo? Por lo general, el rango es [min, max) donde se incluye min y max se excluye. Respuesta incorrecta, rechazada. 1 de marzo de 2017 a las 21:26
  • @MaartenBodewes +1 se agrega porque getRandomNumberBetween genera un número aleatorio exclusivo de los puntos finales proporcionados. 2 mar 2017 a las 9:53
  • 1
    ¡El número min + 1será dos veces más probable que el otro número de ser el resultado de getRandomNumberBetween!
    Lii
    17 de junio de 2018 a las 12:21
19

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);
19
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

O eche un vistazo a RandomUtils de Apache Commons .

3
  • Eso es útil, pero ten cuidado con un pequeño defecto: las firmas de métodos son como: nextDouble (double startInclusive, double endInclusive), pero si miras dentro de los métodos, endInclusive debería ser endExclusive.
    zakmck
    30/01/15 a las 9:27
  • Double.valueOf(Math.random()*(maximum-minimun)).intValue()es una forma bastante confusa (e ineficaz) de decir (int)(Math.random()*(maximum-minimun))...
    Holger
    3 de junio de 2016 a las 9:47
  • Discrepancia ortográfica para retorno mínimo mínimo + Double.valueOf (Math.random () * (máximo - mínimo)). IntValue (); 26 de diciembre de 2016 a las 5:14
18

Aquí hay una clase útil para generar aleatoriamente intsen 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;
    }
}
18

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

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);
    // ...
 }
17
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);
}
16

Encontré este ejemplo Generar 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.
14

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

Puede reutilizarlo como campo en la clase de agujero, también teniendo todos los Random.classmé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;
    }
}
0
14
rand.nextInt((max+1) - min) + min;

Esto está funcionando bien.

14

Es mejor usar SecureRandom en lugar de 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;
}
6
  • 1
    Esto no es tan bueno, porque si se ejecuta en el mismo mili segundo, obtendrá el mismo número, debe poner la inicialización de rand y setSeet fuera del método.
    maraca
    16/04/15 a las 19:30
  • Necesita semilla, sí, pero usando SecureRandom.
    grep
    17/04/15 a las 12:03
  • Lo siento, pero el que rechazó la solicitud de cambio no tiene ni idea de programación en Java. Es una buena sugerencia, pero como está es incorrecta porque si se ejecuta en el mismo milisegundo dará el mismo número, no aleatorio.
    maraca
    18/04/15 a las 9:19
  • La solución correcta no se encuentra por ningún lado, no mucha gente conoce los bloques de inicializadores estáticos ... eso es lo que debe usar para establecer la semilla: 1: private static int SecureRandom rand = new SecureRandom();2: static {3: rand.setSeed(...);4:}
    maraca
    18/04/15 a las 9:30
  • 6
    No hay absolutamente ninguna necesidad de sembrar SecureRandom, será sembrado por el sistema. Llamar directamente setSeedes muy peligroso, puede reemplazar la semilla (realmente aleatoria) con la fecha. Y eso ciertamente no resultará en una SecureRandom, ya que cualquiera puede adivinar la hora e intentar sembrar su propia SecureRandominstancia con esa información. 1 de marzo de 2017 a las 21:32