it-swarm-es.com

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

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

He intentado lo siguiente, pero esos 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`.
3291
user42155

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 JavaDoc relevante . Este enfoque tiene la ventaja de que no es necesario inicializar explícitamente una instancia de 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 manera 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 JavaDoc relevante . En la práctica, la clase Java.util.Random es a menudo preferible a Java.lang.Math.random () .

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

3508
Greg Case

Tenga en cuenta que este enfoque es más sesgado y menos eficiente que el enfoque nextInt, 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 'Max-Min' no está incluido.

Por ejemplo, si desea [5,10), necesita cubrir cinco valores enteros para que use

Math.random() * 5

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

Ahora debe cambiar este rango hasta el rango al que está apuntando. Para ello, agregue 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 está obteniendo un valor doble. Para obtener el valor Max incluido, debe agregar 1 a su parámetro de rango (Max - Min) y luego truncar la parte decimal lanzando 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 según el ejemplo [5,10]:

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

Utilizar:

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.

327
jackson

Utilizar:

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

Con Java-8 introdujeron el método ints(int randomNumberOrigin, int randomNumberBound) en el Random class.

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 puede hacerlo para los valores de double y long.

¡Espero eso ayude! :)

113
Alexis C.

Puedes editar tu segundo ejemplo de código para:

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

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

93
hexabunny

ThreadLocalRandom equivalente de la clase Java.util.Random para entornos 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 ej. (1,10)

60
andrew

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 items, 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 devolverá 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 foroIntervalos aleatorios (archive.org).

60
Matt R

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.

46
Joel Sjöstrand

Me pregunto si alguno de los métodos de generación de números aleatorios provistos por una Apache Commons Math library sería el adecuado. 

Por ejemplo: RandomDataGenerator.nextInt o RandomDataGenerator.nextLong

29
Chinnery

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 min al número aleatorio produciría:

5, 6, 7, 8, 9, 10 

De ahí obtenemos el rango deseado. 

28
Sunil Chawla
 Rand.nextInt((max+1) - min) + min;
24
Michael Myers

Genere un número aleatorio para la diferencia de min y max 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);
20
gifpif

A partir de Java 7, ya no debe usar Random. Para la mayoría de los usos, el Generador de números aleatorios de elección es ahora 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 horquillas 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 aleatoria de int[100] de valores 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);
20
Oleksandr

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

face = 1 + randomNumbers.nextInt(6);
18
sam

Aquí hay una clase útil para generar ints aleatoria 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;
    }
}
18
Garrett Hall
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

O eche un vistazo a RandomUtils desde Apache Commons .

18
user2427

Para generar un número aleatorio "entre dos números", use 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 inicie el valor de UpperBound agregando 1. Por ejemplo, si desea generar un número aleatorio entre 1 a 10, inicialice el número de upperBound con 11 en lugar de 10.

17
Lawakush Kurmi

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 from 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;
}
17
Luke Taylor

Solo usa el Aleatorio clase: 

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

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

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);
15
Mulalo Madida

Cuando necesitas muchos números aleatorios, no recomiendo la clase aleatoria en la API. Tiene un período demasiado pequeño. Pruebe el Mersenne twister en su lugar. Hay una implementación de Java .

15
raupach
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);
}
15
AZ_

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

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

Puede reutilizarlo como campo en la clase de agujero, también teniendo todos los métodos de 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;
    }
}
13
Yakiv Mospan
private static Random random = new Random();    

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

OR

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

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.

11
Abel Callejo

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;
}
11
grep
Rand.nextInt((max+1) - min) + min;

Esto está funcionando bien. 

11
ganesh

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

Puedes convertirlo en un entero si lo deseas.

9
Simon
import Java.util.Random; 

public class RandomUtil {
    // Declare as class variable so that it is not re-seeded every call
    private static Random random = new Random();

    /**
     * Returns a psuedo-random number between min and max (both inclusive)
     * @param min Minimim value
     * @param max Maximim value. Must be greater than min.
     * @return Integer between min and max (both inclusive)
     * @see Java.util.Random#nextInt(int)
     */
    public static int nextInt(int min, int max) {
        // nextInt is normally exclusive of the top value,
        // so add 1 to make it inclusive
        return random.nextInt((max - min) + 1) + min;
    }
}
8
ybn

Puedes hacer algo como esto:

import Java.awt.*;
import Java.io.*;
import Java.util.*;
import Java.math.*;

public class Test {

    public static void main(String[] args) {
        int first, second;

        Scanner myScanner = new Scanner(System.in);

        System.out.println("Enter first integer: ");
        int numOne;
        numOne = myScanner.nextInt();
        System.out.println("You have keyed in " + numOne);

        System.out.println("Enter second integer: ");
        int numTwo;
        numTwo = myScanner.nextInt();
        System.out.println("You have keyed in " + numTwo);

        Random generator = new Random();
        int num = (int)(Math.random()*numTwo);
        System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
    }
}
7
thangaraj

Puede usar este fragmento de código que resolverá su problema: 

Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;

Use myRandomNumber (que le dará un número dentro de un rango).

7
sachit

Un enfoque diferente utilizando Java 8 IntStream y Collections.shuffle

import Java.util.stream.IntStream;
import Java.util.ArrayList;
import Java.util.Collections;

public class Main {

    public static void main(String[] args) {

        IntStream range = IntStream.rangeClosed(5,10);
        ArrayList<Integer> ls =  new ArrayList<Integer>();

        //populate the ArrayList
        range.forEach(i -> ls.add(new Integer(i)) );

        //perform a random shuffle  using the Collections Fisher-Yates shuffle
        Collections.shuffle(ls);
        System.out.println(ls);
    }
}

El equivalente en Scala

import scala.util.Random

object RandomRange extends App{
  val x =  Random.shuffle(5 to 10)
    println(x)
}
6
firephil

Simplemente declararé lo que está mal con las soluciones proporcionadas por la pregunta y por qué los errores. 

Solución 1:

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

Problema: a randomNum se le asignan números de valores mayores que el máximo.

Explicación: suponga que nuestro mínimo es 5, y su máximo es 10. Cualquier valor de Math.random() mayor que 0.6 hará que la expresión evalúe a 6 o mayor, y sumar 5 lo hace mayor que 10 (su máximo). El problema es que está multiplicando el número aleatorio por el máximo (que genera un número casi tan grande como el máximo) y luego agrega el mínimo. A menos que el mínimo sea 1, no es correcto. Tienes que cambiar a, como se menciona en otras respuestas

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

El +1 se debe a que Math.random() nunca devolverá 1.0.

Solución 2:

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

Su problema aquí es que '%' puede devolver un número negativo si el primer término es más pequeño que 0. Ya que rn.nextInt() devuelve valores negativos con un 50% de probabilidad, tampoco obtendrá el resultado esperado.

Esto, sin embargo, fue casi perfecto. Solo tenía que mirar un poco más abajo en el Javadoc, nextInt (int n) . Con ese método disponible, haciendo

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

También devolvería el resultado deseado.

6
Jorge
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
5
namezhouyu

Usted podría usar 

RandomStringUtils.randomNumeric(int count)

método también que es de Apache commons. 

5
false9striker
import Java.util.Random;

public class RandomSSNTest {

    public static void main(String args[]) {
        generateDummySSNNumber();
    }


    //831-33-6049
    public static void generateDummySSNNumber() {
        Random random = new Random();

        int id1 = random.nextInt(1000);//3
        int id2 = random.nextInt(100);//2
        int id3 = random.nextInt(10000);//4

        System.out.print((id1+"-"+id2+"-"+id3));
    }

}

También puedes usar 

import Java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();

Sin embargo, esta clase no se desempeña bien en un entorno de subprocesos múltiples.

4
vaquar khan

Haciendo el siguiente cambio en Intento 1 debería hacer el trabajo - 

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

Compruebe este para el código de trabajo.

4
monster

Estoy pensando en normalizar linealmente los números aleatorios generados en el rango deseado usando lo siguiente. Sea x un número aleatorio, sea a y b el rango mínimo y máximo del número normalizado deseado.

Luego, a continuación se muestra solo un código muy simple para probar el rango producido por el mapeo lineal.

public static void main(String[] args) {
    int a = 100;
    int b = 1000;
    int lowest = b;
    int highest = a;
    int count = 100000;
    Random random = new Random();
    for (int i = 0; i < count; i++) {
        int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
        if (nextNumber < a || nextNumber > b) {
            System.err.println("number not in range :" + nextNumber);
        }
        else {
            System.out.println(nextNumber);
        }
        if (nextNumber < lowest) {
            lowest = nextNumber;
        }
        if (nextNumber > highest) {
            highest = nextNumber;
        }
    }
    System.out.println("Produced " + count + " numbers from " + lowest
            + " to " + highest);
}
4
user591593

Solo genero un número aleatorio usando Math.random () y lo multiplico por un número grande, digamos 10000. Entonces, obtengo un número entre 0 y 10,000 y llamo a este número iAhora, si necesito números entre (x, y), haga lo siguiente:

i = x + (i % (y - x));

Entonces, todos los iname __ 's son números entre x e y.

Para eliminar el sesgo como se señala en los comentarios, en lugar de multiplicarlo por 10000 (o el número grande), multiplíquelo por (y-x).

4
jatin3893

Creo que este código funcionará para ello. Por favor intente esto: 

import Java.util.Random;
public final class RandomNumber {

    public static final void main(String... aArgs) {
        log("Generating 10 random integers in range 1..10.");
        int START = 1;
        int END = 10;
        Random randomGenerator = new Random();
        for (int idx=1; idx<=10; ++idx) {

            // int randomInt=randomGenerator.nextInt(100);
            // log("Generated : " + randomInt);
            showRandomInteger(START,END,randomGenerator);
        }
        log("Done");
    }

    private static void log(String aMessage) {
        System.out.println(aMessage);
    }

    private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
        if (aStart > aEnd) {
            throw new IllegalArgumentException("Start cannot exceed End.");
        }
        long range = (long)aEnd - (long)aStart + 1;
        long fraction = (long) (range * aRandom.nextDouble());
        int randomNumber = (int) (fraction + aStart);
        log("Generated" + randomNumber);
    }
}
3
Akash Malhotra

Si ya usa Commons Lang API 2.x o la última versión, entonces hay una clase para la generación de números aleatorios RandomUtils.

public static int nextInt(int n)

Devuelve un valor int pseudoaleatorio, distribuido uniformemente entre 0 (incluido) y el valor especificado (exclusivo), de la secuencia Math.random ().

Parámetros: n - el valor máximo exclusivo especificado

int random = RandomUtils.nextInt(1000000);

Nota: En RandomUtils tiene muchos métodos para la generación de números aleatorios 

3
Divyesh Kanzariya

El siguiente código genera un número aleatorio entre 100.000 y 900.000. Este código generará valores de seis dígitos. Estoy usando este código para generar un seis dígitos OTP .

Use import Java.util.Random para usar este método aleatorio.

import Java.util.Random;

// Six digits random number generation for OTP
Random rnd = new Random();
long longregisterOTP = 100000 + rnd.nextInt(900000);
System.out.println(longregisterOTP);
3
BMAM

Puede usar la clase Aleatoria para generar un número aleatorio y luego usar .nextInt (maxNumber) para generar un número aleatorio. El número máximo es el número al que desea el máximo al generar un número aleatorio. No obstante, recuerde que la clase aleatoria le da los números del 0 al maxNumber-1. 

Random r = new Random();
int i = r.nextInt();

Otra forma de hacer esto es usar la clase Math.Random () que muchas clases en las escuelas requieren que uses porque es más eficiente y no tienes que declarar un nuevo objeto Random. Para obtener un número aleatorio usando Math.Random (), escribe:

Math.random() * (max - min) + min;
3
f3d0r

Esto generará Lista de números aleatorios con rango (Mín - Máx) con sin duplicados .

generateRandomListNoDuplicate(1000, 8000, 500);

Añade este método.

private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
    Random rng = new Random();
    Set<Integer> generatedList = new LinkedHashSet<>();
    while (generatedList.size() < totalNoRequired) {
        Integer radnomInt = rng.nextInt(max - min + 1) + min;
        generatedList.add(radnomInt);
    }
}

Espero que esto te ayudará.

3
Hiren Patel

He creado un método para obtener un entero único en un rango determinado.

/*
      * minNum is the minimum possible random number
      * maxNum is the maximum possible random number
      * numbersNeeded is the quantity of random number required
      * the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){

    if(minNum >= maxNum)
        throw new IllegalArgumentException("maxNum must be greater than minNum");

    if(! (numbersNeeded > (maxNum - minNum + 1) ))
        throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");

    Random rng = new Random(); // Ideally just create one instance globally

    // Note: use LinkedHashSet to maintain insertion order
    Set<Integer> generated = new LinkedHashSet<Integer>();
    while (generated.size() < numbersNeeded)
    {
        Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;

        // As we're adding to a set, this will automatically do a containment check
        generated.add(next);
    }
    return generated;
}
3
Xar E Ahmer

Digamos que quieres un rango entre 0-9, 0 es mínimo y 9 es máximo. La siguiente función imprimirá cualquier cosa entre 0 y 9. Es la misma para todos los rangos.

public static void main(String[] args) {
    int b = randomNumberRange(0, 9);
    int d = randomNumberRange (100, 200);
    System.out.println("value of b is " + b);
    System.out.println("value of d is " + d);
}

public static int randomNumberRange(int min, int max) {
    int n = (max + 1 - min) + min;
    return (int) (Math.random() * n);
}
3
Siddhartha Thota

Uno de mis amigos me había hecho esta misma pregunta en la universidad hoy (sus requisitos era generar un número aleatorio entre 1 y -1). Así que escribí esto, y funciona bien hasta ahora con mis pruebas. Idealmente, hay muchas formas de generar números aleatorios dado un rango. Prueba esto: 

Función:

private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{

    if (numberOne == numberTwo){
        throw new Exception("Both the numbers can not be equal");
    }

    float Rand = (float) Math.random();
    float highRange = Math.max(numberOne, numberTwo);
    float lowRange = Math.min(numberOne, numberTwo);

    float lowRand = (float) Math.floor(Rand-1);
    float highRand = (float) Math.ceil(Rand+1);

    float genRand = (highRange-lowRange)*((Rand-lowRand)/(highRand-lowRand))+lowRange;

    return genRand;
}

Ejecutar de esta manera:

System.out.println( getRandomNumberBetween(1,-1));
3
Arun Abraham

El siguiente es otro ejemplo usando Random y forEach

int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
3
Sanjeev Singh

Hay una biblioteca en https://sourceforge.net/projects/stochunit/ para manejar la selección de rangos.

StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();

Tiene borde de inclusión/exclusión.

2
ledlogic

Una forma sencilla de generar n números aleatorios entre ayb , Por ejemplo, a = 90, b = 100, n = 20

Random r = new Random();
for(int i =0; i<20; i++){
    System.out.println(r.ints(90, 100).iterator().nextInt());
}

r.ints() devuelve una IntStream y tiene varios métodos útiles, eche un vistazo a su API .

2
Sam2016

Trate de usar la clase org.Apache.commons.lang.RandomStringUtils. Sí, a veces da un número repetido adyacente, pero dará un valor entre 5 y 15:

    while (true)
    {
        int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
        int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
        if ((cd-abc) >= 5 && (cd-abc) <= 15)
        {
            System.out.println(cd-abc);
            break;
        }
    }
2
agpt

Número aleatorio del rango [min..max] incluido:

int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
        .nextInt(min, max + 1);
2
Andrey

Use Java.util para Random para uso general.

Puede definir su rango mínimo y máximo para obtener esos resultados.

Random Rand=new Random();
Rand.nextInt((max+1) - min) + min;
2
Prakhar Nigam

La mayoría de las sugerencias anteriores no consideran "desbordamiento", por ejemplo: min = Integer.MIN_VALUE, max = 100. Uno de los enfoques correctos que tengo hasta ahora es:

final long mod = max- min + 1L;
final int next = (int) (Math.abs(Rand.nextLong() % mod) + min);
2
user_3380739

Esta es la manera fácil de hacer esto.

import Java.util.Random;
class Example{
    public static void main(String args[]){
        /*-To test-
        for(int i = 1 ;i<20 ; i++){
            System.out.print(randomnumber()+",");
        }
        */

        int randomnumber = randomnumber();

    }

    public static int randomnumber(){
        Random Rand = new Random();
        int randomNum = Rand.nextInt(6) + 5;

        return randomNum;
    }
}

Allí 5 es el punto de partida de los números aleatorios. 6 es el rango que incluye el número 5.

2
Gihan Chathuranga
public static void main(String[] args) {

    Random ran = new Random();

    int min, max;
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter min range:");
    min = sc.nextInt();
    System.out.println("Enter max range:");
    max = sc.nextInt();
    int num = ran.nextInt(min);
    int num1 = ran.nextInt(max);
    System.out.println("Random Number between given range is " + num1);

}
1
Alekya

Use math.random() y establezca los requisitos en la sentencia if. El enfoque más fácil, sencillo y rápido. 

0
Arth Tyagi

Utilizando Java 8 Streams,

  • Pase la capacidad inicial - Cuántos números
  • Pase el randomBound - desde x hasta randomBound
  • Pase verdadero/falso por ordenado o no
  • Pasa un nuevo objeto aleatorio ()

public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {

    List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());

    if (sorted)
        numbers.sort(null);

    return numbers;
}

Genera números de 1-Randombound en este ejemplo.

0
Jake O

A continuación se muestra una clase de muestra que muestra cómo generar enteros aleatorios dentro de un rango específico. Asigne cualquier valor que desee como valor máximo a la variable 'max' y asigne cualquier valor que desee como valor mínimo a la variable 'min'.

public class RandomTestClass {

    public static void main(String[] args) {
        Random r = new Random();
        int max = 10;
        int min = 5;
        int x;
        x = r.nextInt(max) + min;
        System.out.println(x);
    }

}
0
Anjali Pavithra

El siguiente código podría ser utilizado:

ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
0
anshul