random repetir - ¿Cómo generar enteros aleatorios dentro de un rango específico en Java?



netbeans cifras (25)

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

He intentado lo siguiente, pero los que no funcionan:

Intento 1:

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

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

Answers

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

Puede reutilizarlo como campo en la clase de agujero, también teniendo todos los métodos Random.class 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;
    }
}

Puedes editar tu segundo ejemplo de código para:

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

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

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

Esto está funcionando bien.


Utilizar:

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

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


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, la cuenta de esto sería max - min + 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

Agregar el valor mínimo al número aleatorio produciría:

5, 6, 7, 8, 9, 10

De ahí obtenemos el rango deseado.



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

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

Para agrupaciones de unión de horquillas y flujos paralelos, use SplittableRandom .

Joshua Bloch. Java efectiva. Tercera edicion.

A partir de Java 8

Para agrupaciones de unión de horquilla y flujos paralelos, use SplittableRandom que generalmente es más rápido, tiene una mejor independencia estadística y propiedades de uniformidad en comparación con Random .

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

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

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

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

Para devolver un flujo de valores aleatorios:

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

Aquí hay una clase útil para generar ints aleatorias 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;
    }
}

Es mejor usar SecureRandom 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;
}

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

O eche un vistazo a RandomUtils de Apache Commons .


Solo bastaría 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


Genere un número aleatorio para la diferencia de mín y máx utilizando el 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);

Utilizar:

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

Solo usa la clase Random :

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

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

Por ejemplo, si desea generar cinco 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 IntStream ilimitado).

Si necesita hacer varias llamadas separadas, puede crear un iterador primitivo infinito desde 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 valores double y long .

¡Espero eso ayude! :)


Puedes lograrlo de forma 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);

En 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 correspondiente JavaDoc . Este enfoque tiene la ventaja de que no es necesario inicializar explícitamente una instancia java.util.Random , que puede ser una fuente de confusión y error si se utiliza de forma inadecuada.

Sin embargo, a la inversa, no hay forma de establecer explícitamente la semilla, por lo que puede ser difícil reproducir los resultados en situaciones en las que es útil, como probar o guardar estados de juegos o similares. En esas situaciones, se puede usar la técnica pre-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 correspondiente JavaDoc . En la práctica, la clase java.util.Random menudo es preferible a java.lang.Math.random() .

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



ThreadLocalRandom equivalente de la clase java.util.Random para un entorno multiproceso. La generación de un número aleatorio se lleva a cabo localmente en cada uno de los hilos. Así que tenemos un mejor desempeño al reducir los conflictos.

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

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


La clase Math.Random en Java está basada en 0. Entonces, si escribes algo como esto:

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

x estará entre 0-9 inclusive.

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

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

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

Para una mejor comprensión, echa un vistazo a la publicación del foro Random Intervals (archive.org) .


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

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

Una solución infalible devolvería los resultados correctos para cualquier min <= max dentro 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 ineficiente, tenga en cuenta que la probabilidad de éxito en el bucle while siempre será del 50% o superior.


Si desea probar la respuesta con la mayoría de los votos arriba, simplemente puede usar este código:

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

    public static void main(String[] args)
    {
        System.out.println(Randomizer.generate(0,10));
    }
}

Es simplemente limpio y simple.


La mejor manera es usar la función de importación aleatoria.

import random
print(random.sample(range(10), 10))

o sin ninguna importación de la biblioteca:

n={} 
for i in range(10):
    n[i]=i

for p in range(10):
    print(n.popitem()[1])

aquí, los popitems eliminan y devuelven un valor arbitrario del diccionario n .





java random integer