repetidos - random entre dois numeros java




Como gerar números inteiros aleatórios dentro de um intervalo específico em Java? (20)

Como faço para gerar um valor int aleatório em um intervalo específico?

Eu tentei o seguinte, mas aqueles não funcionam:

Tentativa 1:

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

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

A partir do Java 7, você não deve mais usar o Random . Para a maioria dos usos, o gerador de números aleatórios de escolha é agora ThreadLocalRandom .

Para conjuntos de SplittableRandom garfo e fluxos paralelos, use SplittableRandom .

Joshua Bloch. Java efetivo. Terceira edição.

A partir do Java 8

Para pools de junção de fork e fluxos paralelos, use SplittableRandom que geralmente é mais rápido, tem uma melhor independência estatística e propriedades de uniformidade em comparação com Random .

Para gerar um int aleatório no intervalo [0, 1_000]:

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

Para gerar um array int[100] aleatório de valores no intervalo [0, 1_000]:

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

Para retornar um fluxo de valores aleatórios:

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

É melhor usar SecureRandom ao invés de apenas 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;
}

Apenas uma pequena modificação de sua primeira solução seria suficiente.

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

Veja mais aqui para implementação do Random


Apenas use a classe Random :

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

Aqui está uma classe útil para gerar ints aleatórios em um intervalo com qualquer combinação de limites 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;
    }
}

Com o java-8 eles introduziram o método ints(int randomNumberOrigin, int randomNumberBound) na classe Random .

Por exemplo, se você quiser gerar cinco inteiros aleatórios (ou um único) no intervalo [0, 10], faça:

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

O primeiro parâmetro indica apenas o tamanho do IntStream gerado (que é o método sobrecarregado daquele que produz um IntStream ilimitado).

Se você precisar fazer várias chamadas separadas, poderá criar um iterador primitivo infinito do fluxo:

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

Você também pode fazer isso para valores double e long .

Espero que ajude! :)


Esses métodos podem ser convenientes para usar:

Este método retornará um número aleatório entre o valor min e max fornecido:

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

e este método retornará um número aleatório do valor min e max fornecido (assim, o número gerado também pode ser o número mínimo ou máximo):

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

Eu encontrei este exemplo Gerar números aleatórios :

Este exemplo gera números inteiros aleatórios em um intervalo 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);
  }
} 

Um exemplo executado desta classe:

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.


No Java 1.7 ou posterior , a maneira padrão de fazer isso é a seguinte:

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

Veja o JavaDoc relevante . Essa abordagem tem a vantagem de não precisar inicializar explicitamente uma instância java.util.Random , que pode ser uma fonte de confusão e erro se usada de forma inadequada.

No entanto, inversamente, não há como definir explicitamente a semente, portanto, pode ser difícil reproduzir os resultados em situações em que isso é útil, como testar ou salvar estados de jogo ou semelhantes. Nessas situações, a técnica pré-Java 1.7 mostrada abaixo pode ser usada.

Antes do Java 1.7 , a maneira padrão de fazer isso é a seguinte:

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

Veja o JavaDoc relevante . Na prática, a classe java.util.Random geralmente é preferível a java.lang.Math.random() .

Em particular, não há necessidade de reinventar a roda de geração de inteiros aleatórios quando houver uma API direta dentro da biblioteca padrão para realizar a tarefa.


Observe que essa abordagem é mais tendenciosa e menos eficiente do que uma abordagem nextInt , https://.com/a/738651/360211

Um padrão padrão para realizar isso é:

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

A função de biblioteca matemática Math.random () gera um valor duplo no intervalo [0,1) . Observe que esse intervalo não inclui o 1.

Para obter um intervalo específico de valores primeiro, você precisa multiplicar pela magnitude do intervalo de valores que deseja cobrir.

Math.random() * ( Max - Min )

Isso retorna um valor no intervalo [0,Max-Min) , onde 'Max-Min' não está incluído.

Por exemplo, se você quiser [5,10) , você precisa cobrir cinco valores inteiros para usar

Math.random() * 5

Isso retornaria um valor no intervalo [0,5) , onde 5 não está incluído.

Agora você precisa mudar esse intervalo para o intervalo que você está alvejando. Você faz isso adicionando o valor Min.

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

Você agora receberá um valor no intervalo [Min,Max) . Seguindo nosso exemplo, isso significa [5,10) :

5 + (Math.random() * (10 - 5))

Mas, isso ainda não inclui Max e você está obtendo um valor duplo. Para obter o valor Max incluído, você precisa adicionar 1 ao seu parâmetro de intervalo (Max - Min) e, em seguida, truncar a parte decimal enviando para um int. Isso é realizado via:

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

E aí você tem isso. Um valor inteiro aleatório no intervalo [Min,Max] ou pelo exemplo [5,10] :

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

Outra opção é apenas usar o 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);
    // ...
 }


Se você quiser tentar a resposta com o maior número de votos acima, você pode simplesmente 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));
    }
}

É apenas limpo e simples.


Usar:

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

Vamos dar um exemplo.

Suponha que eu queira gerar um 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);

Vamos entender isso ...

Inicialize max com o maior valor e min com o menor valor.

Agora, precisamos determinar quantos valores possíveis podem ser obtidos. Para este exemplo, seria:

5, 6, 7, 8, 9, 10

Então, a contagem disso seria max - min + 1.

ou seja, 10 - 5 + 1 = 6

O número aleatório irá gerar um número entre 0 e 5 .

ou seja, 0, 1, 2, 3, 4, 5

Adicionar o valor mínimo ao número aleatório produziria:

5, 6, 7, 8, 9, 10

Por isso, obtemos o intervalo desejado.


Você pode editar seu segundo exemplo de código para:

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

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

OU

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