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

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

He intentado lo siguiente, pero no funcionan:

Intento 1:

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

Error: randomNum puede 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: randomNum puede ser más pequeño que minimum.

preguntado el 12 de diciembre de 08 a las 16:12

Cuando necesita muchos números aleatorios, no recomiendo la clase Random en la API. Tiene un período demasiado pequeño. Prueba el Tornado de Mersenne en lugar de. Hay una implementación de Java. -

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

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

30 Respuestas

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

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

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

Respondido 14 Oct 18, 18:10

Para llamadas donde max Valor es Integer.MAX_VALUE es posible que se desborde, lo que resulta en un java.lang.IllegalArgumentException. Puedes probar con: randInt(0, Integer.MAX_VALUE). También 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

@leventov ThreadLocalRandom se agregó a Java 2 1/2 años después de que se formuló 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. - Greg caso

En Android Random rand = new Random (); - Webserveis

@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. - Greg caso

@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. - Greg caso

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

Respondido 08 Feb 19, 14:02

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. - Lilian A. Moraru

Esto en realidad está sesgado en comparación con los métodos nextInt stackoverflow.com/a/738651/360211 - weston

En este caso, "sesgado" significa que después de 2 ^ 53 ejecuciones, algunos números habrán tenido una ocurrencia adicional, en promedio. - Cefalópodo

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. - Tobías

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.

Respondido 08 Feb 19, 14:02

Uso:

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

Respondido el 22 de junio de 14 a las 23:06

Con introdujeron el método ints(int randomNumberOrigin, int randomNumberBound) en el objeto 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! :)

Respondido 02 Abr '20, 16:04

Le sugiero que cree una instancia de randomIterator solo una vez. Vea el comentario de Greg Case sobre su propia respuesta. - Naxos 84

Puede editar su segundo ejemplo de código para:

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

Respondido 08 Feb 19, 13:02

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

Respondido 08 Feb 19, 14:02

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

Respuesta duplicada con al menos 7 años de retraso. - Maarten Bodewes

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)

respondido 23 mar '20, 20:03

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

Respondido 08 Feb 19, 14:02

+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

Me desconcierta por qué instancias index a 0. - charles-allen

@CodeConfident El index La variable no afectará el resultado del número aleatorio. Puede elegir inicializarlo de la forma que desee sin tener que preocuparse por cambiar el resultado. Espero que esto ayude. - Matt R

Exactamente ... está completamente sin usar. Lo inicializaría directamente en el rand: int index = rand.nextInt(i.Length); - charles-allen

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

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.

Respondido 12 Jul 19, 19:07

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

Eso es correcto @MaartenBodewes. Cuando escribí esta respuesta, la respuesta con más votos arriba todavía estaba escrito 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. - Abel Callejo

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? - levi l

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.

Respondido 23 Abr '18, 06:04

¿Por qué no lanzar una IllegalArgumentException cuando la diferencia = Integer.MAX_VALUE? Entonces no necesitas el bucle while. - MP Korstanje

@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. - cristian semrau

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

respondido 16 nov., 16:12

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.

Respondido 08 Feb 19, 14:02

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

Respondido el 20 de diciembre de 17 a las 19:12

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.

Respondido 01 ago 19, 07:08

Esta función produce el mismo número una y otra vez. En mi caso fue: 2147483647 - sokras

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? - Maarten Bodewes

@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 que 2147483647 es Integer.MAX_VALUE; la salida obviamente depende de la entrada, que no ha especificado. - Maarten Bodewes

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

Respondido 08 Feb 19, 14:02

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

Respondido 08 Feb 19, 08:02

¿Hay alguna razón por la que el ejemplo incluye un .parallel()? Me parece que generar 100 números aleatorios sería demasiado trivial para garantizar el paralelismo. - Juanbot

@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 parallel Procesando). Por cierto, para una variedad de 1_000_000 elementos, el parallel La versión fue 2 veces más rápida en mi máquina en comparación con la secuencial. - Oleksandr Pyrohov

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.

Respondido 08 Feb 19, 14:02

Solo usa el Aleatorio clase:

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

Respondido 08 Feb 19, 14:02

No veo nada nuevo aquí que no se haya publicado en innumerables publicaciones anteriores. - Maarten Bodewes

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

Respondido 08 Feb 19, 14:02

// 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. - Maarten Bodewes

@MaartenBodewes +1 se agrega porque getRandomNumberBetween genera un número aleatorio exclusivo de los puntos finales proporcionados. - lucas taylor

El número min + 1 será dos veces más probable que el otro número de ser el resultado de getRandomNumberBetween! - lii

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

Respondido 21 Abr '16, 07:04

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

O eche un vistazo a RandomUtils desde Apache Commons.

Respondido 08 Feb 19, 14:02

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

Double.valueOf(Math.random()*(maximum-minimun)).intValue() es una forma bastante confusa (e ineficiente) de decir (int)(Math.random()*(maximum-minimun))... - Holger

Discrepancia ortográfica para retorno mínimo mínimo + Double.valueOf (Math.random () * (máximo - mínimo)). IntValue (); - Hrishikesh Mishra

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

Respondido 15 Feb 12, 16:02

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

Respondido 08 Feb 19, 14:02

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

Respondido 08 Feb 19, 14:02

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

Respondido 23 Abr '18, 06:04

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.

Respondido 08 Feb 19, 14:02

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

Respondido 06 Jul 16, 20:07

Esto no es tan bueno, porque si se ejecuta en el mismo mili segundo, obtendrá el mismo número, debe colocar la inicialización de rand y el setSeet fuera del método. - maraca

Necesita semilla, sí, pero usando SecureRandom. - grep

Lo siento, pero el que rechazó la solicitud de cambio no tiene ni idea de la programación Java. Es una buena sugerencia, pero como está mal porque si se ejecuta en el mismo milisegundo dará el mismo número, no aleatorio. - maraca

La solución correcta no se encuentra en 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

No hay absolutamente ninguna necesidad de sembrar SecureRandom, será sembrado por el sistema. Llamando directamente setSeed es muy peligroso, puede reemplazar la semilla (realmente aleatoria) con la fecha. Y eso sin duda no resultar en un SecureRandom, ya que cualquiera puede adivinar la hora e intentar sembrar su propia SecureRandom instancia con esa información. - Maarten Bodewes

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

respondido 28 nov., 14:00

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

Esto está funcionando bien.

Respondido 21 Abr '16, 07:04

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.