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




random java rango (20)

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

https://code.i-harness.com


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

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



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

face = 1 + randomNumbers.nextInt(6);

Encontré este ejemplo Generar números aleatorios :

Este ejemplo genera 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.

Estos métodos pueden ser convenientes de usar:

Este método devolverá un número aleatorio entre los valores mínimo y máximo proporcionados:

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

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


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

Puedes editar tu segundo ejemplo de código para:

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

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

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


Solo usa la clase Random :

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

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)


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.


Utilizar:

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

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

private static Random random = new Random();    

public static int getRandomInt(int min, int max){
  return random.nextInt(max - min + 1) + min;
}

O

public static int getRandomInt(Random random, int min, int max)
{
  return random.nextInt(max - min + 1) + min;
}

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




integer