Jak wygenerować losowe liczby całkowite w określonym zakresie w Javie?

Jak wygenerować losową intwartość w określonym zakresie?

Próbowałem następujące, ale te nie działają:

Próba 1:

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

Próba 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`.

W Javie 1.7 lub nowszej standardowy sposób to zrobić:

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

Zobacz odpowiedni JavaDoc . Zaletą tego podejścia jest to, że nie trzeba jawnie inicjować instancji java.util.Random , która może być źródłem nieporozumień i błędów, jeśli zostanie użyta niewłaściwie.

Jednak z drugiej strony nie ma sposobu, aby jawnie ustawić ziarno, więc może być trudno odtworzyć wyniki w sytuacjach, w których jest to przydatne, takich jak testowanie lub zapisywanie stanów gry lub podobne. W takich sytuacjach można zastosować technikę wcześniejszą niż Java 1.7.

W wersjach wcześniejszych niż Java 1.7 standardowy sposób to zrobić:

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

Zobacz odpowiedni JavaDoc . W praktyce klasa java.util.Random jest często lepsza niż java.lang.Math.random () .

W szczególności nie ma potrzeby ponownego tworzenia koła losowego generowania liczb całkowitych, gdy w standardowej bibliotece znajduje się prosty interfejs API do wykonania zadania.

Pamiętaj, że to podejście jest bardziej stronnicze i mniej wydajne niż nextIntpodejście, https://stackoverflow.com/a/738651/360211

Jednym standardowym wzorcem do osiągnięcia tego jest:

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

Funkcja biblioteczna Java Math Math.random () generuje podwójną wartość w zakresie [0,1). Zauważ, że ten zakres nie obejmuje 1.

Aby najpierw uzyskać określony zakres wartości, należy pomnożyć przez wielkość zakresu wartości, które chcesz uwzględnić.

Math.random() * ( Max - Min )

Zwraca wartość z zakresu [0,Max-Min), w którym nie jest uwzględnione „Max-Min”.

Na przykład, jeśli chcesz [5,10), musisz podać pięć wartości całkowitych, abyś mógł użyć

Math.random() * 5

Zwróciłoby to wartość z zakresu [0,5), w którym 5 nie jest uwzględnione.

Teraz musisz przesunąć ten zakres do zakresu, na który celujesz. Robisz to, dodając wartość Min.

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

Otrzymasz teraz wartość z zakresu [Min,Max). Idąc za naszym przykładem, oznacza to [5,10):

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

Ale to wciąż nie obejmuje Maxi dostajesz podwójną wartość. Aby uwzględnić Maxwartość, musisz dodać 1 do parametru zakresu, (Max - Min)a następnie skrócić część dziesiętną, rzutując na liczbę całkowitą. Odbywa się to poprzez:

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

I masz to. Losowa wartość całkowita w zakresie [Min,Max]lub na przykład [5,10]:

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

Posługiwać się:

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

Liczba całkowita xjest teraz liczbą losową, z możliwym wynikiem 5-10.

Posługiwać się:

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

Z java-8wprowadzili metodę ints(int randomNumberOrigin, int randomNumberBound)w Randomklasie.

Na przykład, jeśli chcesz wygenerować pięć losowych liczb całkowitych (lub jedną) z zakresu [0, 10], po prostu wykonaj:

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

Pierwszy parametr wskazuje tylko rozmiar IntStreamwygenerowanego (który jest przeciążonym sposobem tego, który wytwarza nieograniczoną liczbę IntStream).

Jeśli potrzebujesz wykonać wiele osobnych wywołań, możesz utworzyć nieskończony prymitywny iterator ze strumienia:

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

Możesz to również zrobić dla doublei longwartości. Mam nadzieję, że to pomoże! :)

Możesz edytować swój drugi przykład kodu, aby:

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

Wystarczy niewielka modyfikacja pierwszego rozwiązania.

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

Zobacz więcej tutaj na temat wdrażania Random

ThreadLocalRandomodpowiednik klasy java.util.Randomdla środowiska wielowątkowego. Generowanie liczby losowej odbywa się lokalnie w każdym wątku. Mamy więc lepszą wydajność, redukując konflikty.

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

x, y- interwały np. (1,10)

Math.RandomKlasa w Javie jest 0 oparte. Jeśli więc napiszesz coś takiego:

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

xbędzie między 0-9włącznie.

Biorąc pod uwagę następującą tablicę 25elementów, kod generujący losową liczbę pomiędzy 0(podstawą tablicy) i array.lengthpowinien wyglądać następująco:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

Ponieważ i.lengthpowróci 25, nextInt( i.length )zwróci liczbę między zakresem 0-24. Inna opcja dotyczy tego, Math.Randomktóry działa w ten sam sposób.

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

Aby lepiej zrozumieć, sprawdź post na forum Random Intervals (archive.org) .

Wybacz mi, że jestem wybredny, ale rozwiązanie sugerowane przez większość, tj. min + rng.nextInt(max - min + 1))Wydaje się niebezpieczne ze względu na to, że:

• rng.nextInt(n)nie może dosięgnąć Integer.MAX_VALUE.
• (max - min)może powodować przepełnienie, gdy minjest ujemne.

Niezawodne rozwiązanie zwróci prawidłowe wyniki dla dowolnego min <= maxw [ Integer.MIN_VALUE, Integer.MAX_VALUE]. Rozważ następującą naiwną implementację:

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

Chociaż nieefektywne, należy pamiętać, że prawdopodobieństwo sukcesu w whilepętli zawsze będzie wynosić 50% lub więcej.

Można to zrobić po prostu wykonując instrukcję:

Randomizer.generate(0,10); //min of zero, max of ten

Poniżej znajduje się jego kod źródłowy

Randomizer.java

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

To jest po prostu czyste i proste.

Zastanawiam się, czy którakolwiek z metod generowania liczb losowych dostarczonych przez bibliotekę Apache Commons Math pasuje do rachunku.

Na przykład: RandomDataGenerator.nextIntlubRandomDataGenerator.nextLong

Weźmy przykład.

Załóżmy, że chcę wygenerować liczbę między 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);

Pozwól nam to zrozumieć ...

Zainicjuj maks. Z najwyższą wartością i min z najniższą wartością.

Teraz musimy ustalić, ile możliwych wartości można uzyskać. W tym przykładzie byłoby to:

5, 6, 7, 8, 9, 10

Tak więc policzenie tego wynosi max - min + 1.

tj. 10 - 5 + 1 = 6

Liczba losowa wygeneruje liczbę między 0-5 .

tj. 0, 1, 2, 3, 4, 5

Dodanie wartości minimalnej do liczby losowej spowodowałoby:

5, 6, 7, 8, 9, 10

W ten sposób uzyskujemy pożądany zakres.

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

Wygeneruj liczbę losową dla różnicy min i maks przy użyciu metody nextint (n) , a następnie dodaj liczbę minimalną do wyniku:

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

Używam tego:

 /**
   * @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;
 }

Jeśli chcesz, możesz rzucić go na liczbę całkowitą.

Począwszy od wersji Java 7, nie powinieneś już używać Random. W przypadku większości zastosowań jest teraz wybrany generator liczb losowych ThreadLocalRandom.

W przypadku pul złączeń wideł i strumieni równoległych użyj SplittableRandom.

Joshua Bloch. Skuteczna Java. Trzecia edycja.

Począwszy od Java 8

W przypadku pul złączeń wideł i strumieni równoległych użycie, SplittableRandomktóre jest zwykle szybsze, ma lepszą statystyczną niezależność i jednolitość w porównaniu z Random.

Aby wygenerować losową intw zakresie[0, 1_000]:

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

Aby wygenerować losową int[100]tablicę wartości z zakresu[0, 1_000]:

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

Aby zwrócić strumień losowych wartości:

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

Wystarczy użyć klasy Random :

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

Te metody mogą być wygodne w użyciu:

Ta metoda zwróci losową liczbę między podaną wartością minimalną i maksymalną:

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

i ta metoda zwróci losową liczbę z podanej wartości minimalnej i maksymalnej (więc wygenerowana liczba może być również liczbą minimalną lub maksymalną):

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

    return randomNumber;
}

W przypadku rzutu kostką byłaby to liczba losowa od 1 do 6 (nie od 0 do 6), więc:

face = 1 + randomNumbers.nextInt(6);

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

Lub spójrz na RandomUtils z Apache Commons .

Oto przydatna klasa do generowania losowego intsw zakresie z dowolną kombinacją granic włączających / wyłączających:

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

Aby wygenerować liczbę losową „pomiędzy dwiema liczbami”, użyj następującego kodu:

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

Daje to liczbę losową z przedziału od 1 (włącznie) do 11 (wyłącznie), więc zainicjuj wartość upperBound, dodając 1. Na przykład, jeśli chcesz wygenerować liczbę losową od 1 do 10, zainicjuj górną liczbę od 11 zamiast 10

Możesz to zwięźle osiągnąć w Javie 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);

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

Inną opcją jest właśnie użycie 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);
    // ...
 }

Znalazłem ten przykład Wygeneruj losowe liczby :

Ten przykład generuje losowe liczby całkowite w określonym zakresie.

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

Przykładowy przebieg tej klasy:

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.

Lepiej jest używać SecureRandom niż tylko 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;
}

Oto prosta próbka, która pokazuje, jak wygenerować liczbę losową z zamkniętego [min, max] zakresu, natomiastmin <= max is true

Możesz użyć go ponownie jako pola w klasie dziur, również mając wszystko Random.class metody w jednym miejscu

Przykład wyników:

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

Źródła:

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

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

To działa dobrze.