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

pytanie utworzone w Sat, Jan 5, 2019 12:00 AM

Jak wygenerować losową wartość int w określonym zakresie?

Próbowałem następujących rzeczy, 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`.
    
3240
30 odpowiedzi                              30                         

W Java 1.7 lub nowszej wersji standardowym sposobem jest:

 
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 . Podejście to ma tę zaletę, że nie wymaga jawnego inicjowania java.util.Random , która może być źródłem nieporozumień i błędów, jeśli jest niewłaściwie używana.

Jednak na odwrót nie ma możliwości jawnego ustawienia nasienia, aby odtworzenie wyników było trudne, np. podczas testowania lub zapisywania stanów gry lub podobnych. W takich sytuacjach można użyć pokazanej poniżej techniki Java w wersji 1.7.

Przed Java 1.7 standardowym sposobem na to jest:

 
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 java Klasa .util.Random jest często lepsza niż java.lang.Math.random () .

W szczególności nie ma potrzeby wymyślania losowego koła generującego liczby całkowite, gdy w standardowej bibliotece istnieje proste API do wykonania zadania.

    
3591
2018-10-14 17: 08: 35Z
  1. W przypadku połączeń, w których max ma wartość Integer.MAX_VALUE, możliwe jest przepełnienie, co daje java.lang.IllegalArgumentException. Możesz spróbować z: randInt(0, Integer.MAX_VALUE). Ponadto, jeśli nextInt((max-min) + 1) zwraca najwyższą wartość (zakładam, że jest to dość rzadkie), to czy nie przepełni się ponownie (jeśli min i max są wystarczająco wysokimi wartościami)? Jak radzić sobie z tego rodzaju sytuacjami?
    2014-08-12 10: 34: 30Z
  2. To nie działa przez długi czas
    2015-02-23 06: 26: 46Z
  3. @ MoisheLipsker Musi być tak, że nextLong nie bierze udziału jako nextInteger
    2015-06-17 18: 42: 57Z
  4. @ leventov ThreadLocalRandom został dodany do Java 2 i pół roku po pierwszym pytaniu. Zawsze uważałem, że zarządzanie przypadkiem losowym wykracza poza zakres pytania.
    2015-09-11 01: 57: 18Z
  5. W systemie Android Random rand = new Random ();
    2016-10-03 19: 55: 05Z

Zauważ, że to podejście jest bardziej stronnicze i mniej wydajne niż podejście nextInt, https://stackoverflow.com/a/738651/360211

Jednym ze standardowych wzorów do osiągnięcia tego jest:

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

Java Funkcja biblioteki matematycznej 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 cożywiony.

 
Math.random() * ( Max - Min )

Zwraca wartość z zakresu [0,Max-Min), gdzie nie ma „Max-Min”.

Na przykład, jeśli chcesz [5,10), musisz pokryć pięć wartości całkowitych, więc używaj

 
Math.random() * 5

Spowoduje to zwrócenie wartości z zakresu [0,5), gdzie 5 nie jest uwzględnione.

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

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

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

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

Ale to nadal nie obejmuje Max i otrzymujesz podwójną wartość. Aby uzyskać wartość Max, należy dodać 1 do parametru zakresu (Max - Min), a następnie skrócić część dziesiętną, rzucając do int. Osiąga 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))
    
1383
2019-02-08 14: 13: 34Z
  1. Dokumentacja Sun wyraźnie mówi, że powinieneś lepiej użyć Random (), jeśli potrzebujesz int zamiast Math.random (), co daje podwójne.
    2012-02-23 23: 26: 34Z
  2. To jest w rzeczywistości stronnicze w porównaniu do metod nextInt stackoverflow.com/a/738651 /360211
    2016-12-29 13: 35: 53Z

Użyj:

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

Liczba całkowita x jest teraz liczbą losową, która ma możliwy wynik 5-10.

    
338
2019-02-08 14: 14: 20Z

Użyj:

 
minimum + rn.nextInt(maxValue - minvalue + 1)
    
143
2014-06-22 22: 22: 52Z

Z przedstawili metodę ints(int randomNumberOrigin, int randomNumberBound) w Random klasie.

Na przykład, jeśli chcesz wygenerować pięć losowych liczb całkowitych (lub jedną) w zakresie [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 IntStream wygenerowanego (który jest przeciążoną metodą tego, który wytwarza nieograniczoną liczbę IntStream).

Jeśli chcesz wykonać wiele oddzielnych 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 zrobić również dla wartości double i long.

Mam nadzieję, że to pomoże! :)

    
118
2019-02-08 14: 14: 56Z
  1. Proponowałbym utworzenie instancji randomIterator tylko raz. Zobacz komentarz Grega Case'a do własnej odpowiedzi.
    2018-02-26 07: 13: 43Z
  2. jeśli możesz, możesz wyjaśnić, jakie znaczenie ma streamSize - pierwszy parametr tej metody podany streamSize !=0. Jaka jest różnica, jeśli podano streamSize 1/2 /n?
    2018-04-10 10: 39: 40Z

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;
    
100
2019-02-08 13: 02: 02Z

Wystarczy mała modyfikacja twojego pierwszego rozwiązania.

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

Więcej informacji o implementacji Random

    
97
2019-02-08 14: 14: 29Z
  1. Dla minimum < = wartość < maksymalnie, zrobiłem to samo z Math: randomNum = minimum + (int) (Math.random () * (maximum-minimum)); ale rzutowanie nie jest zbyt przyjemne;)
    2016-07-08 12: 30: 15Z

    ThreadLocalRandom odpowiednik klasy java.util.Random dla środowiska wielowątkowego. Generowanie liczby losowej odbywa się lokalnie w każdym z wątków. Mamy więc lepszą wydajność, zmniejszając konflikty.

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

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

        
    62
    2016-04-21 06: 03: 42Z

    Klasa Math.Random w Java jest oparta na 0. Więc jeśli napiszesz coś takiego:

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

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

    Tak więc, biorąc pod uwagę następującą tablicę 25 elementów, kod generujący losową liczbę między 0 (podstawa tablicy) a array.length będzie następujący:

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

    Ponieważ i.length zwróci 25, nextInt( i.length ) zwróci liczbę z zakresu 0-24. Inna opcja to Math.Random, która działa w ten sam sposób.

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

    Dla lepszego zrozumienia sprawdź post na forum Losowe interwały (archive.org) .

        
    61
    2019-02-08 14: 14: 25Z
    1. + 1 dla archiwum wayBackMachine zrzutu ekranu i amp; Twoja odpowiedź jest nadal przydatna, aby uzyskać „losowe” int /w zakresie.
      2016-10-30 05: 44: 57Z
    2. Zaskakuje mnie, dlaczego tworzysz indeks do 0.
      2017-08-02 13: 53: 53Z
    3. @ CodeConfident Zmienna index nie wpłynie na wynik liczby losowej. Możesz go zainicjować w dowolny sposób, nie martwiąc się o zmianę wyniku. Mam nadzieję, że to pomoże.
      2017-08-02 14: 38: 52Z
    4. Dokładnie ... jest całkowicie nieużywany. Inicjalizowałbym go bezpośrednio na rand: int index = rand.nextInt(i.Length);
      2017-08-02 14: 41: 09Z

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

    •  rng.nextInt(n) nie może osiągnąć Integer.MAX_VALUE.
    •  (max - min) może spowodować przepełnienie, gdy min jest ujemne.

    Niezawodne rozwiązanie zwróci poprawne wyniki dla dowolnego min <= max w [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, zwróć uwagę, że prawdopodobieństwo powodzenia w pętli while zawsze będzie wynosić 50% lub więcej.

        
    48
    2018-04-23 05: 21: 33Z
    1. Dlaczego nie rzucić wyjątku IllegalArgumentException, gdy różnica = Integer.MAX_VALUE? Wtedy nie potrzebujesz pętli while.
      2015-01-09 10: 27: 57Z
    2. @ mpkorstanje Ta implementacja została zaprojektowana do pracy z dowolnymi wartościami min < = max, nawet jeśli ich różnica jest równa lub nawet większa niż MAX_VALUE. Uruchamianie pętli do sukcesu jest w tym przypadku powszechnym wzorcem, aby zagwarantować równomierną dystrybucję (jeśli podstawowe źródło losowości jest jednolite). Random.nextInt (int) robi to wewnętrznie, gdy argument nie jest potęgą 2.
      2015-05-06 19: 27: 30Z

    Zastanawiam się, czy któraś z metod generowania liczb losowych zapewniana przez Apache Commons Math biblioteka pasowałaby do rachunku.

    Na przykład: RandomDataGenerator.nextInt lub RandomDataGenerator.nextLong

        
    33
    2016-11-16 12: 08: 17Z

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

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

    Poniżej znajduje się 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));
        }
    }
    

    Jest po prostu czysty i prosty.

        
    31
    2019-03-03 14: 29: 04Z
    1. To mogła być edycja innego przykładu, teraz jest to po prostu rażąca kopia dla reputacji. Wskazanie „odpowiedzi z największą liczbą głosów” również nie jest bardzo bezpośrednie, może się zmienić.
      2017-06-19 21: 23: 47Z
    2. To prawda @MaartenBodewes. Kiedy napisałem tę odpowiedź, odpowiedź z największą liczbą głosów powyżej była nadal zapisywana jako rozwiązanie podobne do algorytmu. Teraz powyższe rozwiązanie bardzo się zmieniło i teraz ta odpowiedź wyglądała jak kopia-kot.
      2017-06-20 00: 36: 07Z

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

    Rozumiemy to ...

      
        

    Zainicjuj max 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, byłoby to maksimum - 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 min do liczby losowej spowodowałoby:

             
          

    5, 6, 7, 8, 9, 10

        
             

    Stąd otrzymujemy pożądany zakres.

      
        
    30
    2019-02-08 14: 14: 10Z
     
     rand.nextInt((max+1) - min) + min;
    
        
    27
    2017-12-20 19:34:30Z

    Wygeneruj losową liczbę dla różnicy min i max, używając nextint (n) , a następnie dodaj liczbę min do wyniku:

     
    Random rn = new Random();
    int result = rn.nextInt(max - min + 1) + min;
    System.out.println(result);
    
        
    22
    2019-02-08 14: 15: 07Z
      

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

    Dla pul i połączeń równoległych   strumieni, użyj SplittableRandom .

    Joshua Bloch. Skuteczna Java. Wydanie trzecie.

    Począwszy od Java 8

    W przypadku pul połączeń widłowych i strumieni równoległych użyj SplittableRandom, który jest zwykle szybszy, ma lepszą niezależność statystyczną i właściwości jednolitości w porównaniu z Random.

    Aby wygenerować losowy int w zakresie [0, 1_000]:

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

    Aby wygenerować losową tablicę int[100] wartości w zakresie [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);
    
        
    21
    2019-02-08 08: 56: 49Z
    1. Czy istnieje powód, dla którego przykład zawiera .parallel()? Wydaje mi się, że wygenerowanie 100 liczb losowych byłoby zbyt trywialne, aby zagwarantować równoległość.
      2018-07-20 06: 29: 12Z
    2. @ Johnbot Dziękujemy za komentarz, masz rację. Ale głównym powodem było pokazanie API (oczywiście inteligentna ścieżka polega na pomiarze wydajności przed użyciem przetwarzania parallel). Przy okazji, dla tablicy 1_000_000 elementów, wersja parallel była 2 razy szybsza na moim komputerze w porównaniu z sekwencyjną.
      2018-07-20 08: 35: 20Z

    Oto pomocna klasa do generowania losowych ints w zakresie z dowolną kombinacją wyłącznych /wyłącznych granic:

     
    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;
        }
    }
    
        
    19
    2012-02-15 16: 19: 03Z

    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);
    
        
    19
    2016-04-21 06: 01: 47Z

    Aby wygenerować losową liczbę „mię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 losową liczbę od 1 (włącznie) do 11 (wyłącznie), więc zainicjuj wartość upperBound dodając 1. Na przykład, jeśli chcesz wygenerować losową liczbę od 1 do 10, zainicjuj numer upperBound za pomocą 11 zamiast 10.

        
    19
    2019-02-08 14: 09: 12Z
     
    int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
    

    Lub spójrz na RandomUtils z Apache Commons .

        
    19
    2019-02-08 14: 11: 23Z
    1. To jest przydatne, ale uważaj na małą wadę: podpisy metod są jak: nextDouble (podwójny startInclusive, podwójny endInclusive), ale jeśli zajrzysz do metod, endInclusive powinno być w rzeczywistości endExclusive.
      2015-01-30 09: 27: 17Z
    2. Double.valueOf(Math.random()*(maximum-minimun)).intValue() to dość zaciemniony (i nieefektywny) sposób powiedzenia (int)(Math.random()*(maximum-minimun))
      2016-06-03 09: 47: 15Z
    3. Niezgodność pisowni dla minimalnego minimum zwrotu + Double.valueOf (Math.random () * (maximum - minimum)). intValue ();
      2016-12-26 05: 14: 23Z

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

    Ta metoda zwróci losową liczbę between podaną wartość 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 podaną wartość minimalną i maksymalną (więc wygenerowaną liczbą może być również liczba minimalna lub maksymalna):

     
    public static int getRandomNumberFrom(int min, int max) {
        Random foo = new Random();
        int randomNumber = foo.nextInt((max + 1) - min) + min;
    
        return randomNumber;
    }
    
        
    19
    2019-02-08 14: 14: 37Z
    1. // Since the random number is between the min and max values, simply add 1. Czemu? Czy min? Zazwyczaj zakres wynosi [min, maks.], Gdzie uwzględniono min, a maksimum jest wykluczone. Błędna odpowiedź, odrzucona.
      2017-03-01 21: 26: 35Z
    2. Dodano @ MaartenBodewes +1, ponieważ getRandomNumberBetween generuje losową liczbę z wyłączeniem dostarczonych punktów końcowych.
      2017-03-02 09: 53: 53Z
    3. Liczba min + 1 będzie dwa razy bardziej prawdopodobna niż liczba pozostałych w wyniku getRandomNumberBetween!
      2018-06-17 12: 21: 50Z

    Możesz to osiągnąć zwięźle 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);
    
        
    17
    2019-02-08 14: 14: 15Z

    Znalazłem ten przykład Generowanie liczb losowych :


    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.
    
        
    17
    2019-02-08 14: 14: 44Z

    Skorzystaj z Losowej klasy :

     
    Random ran = new Random();
    // Assumes max and min are non-negative.
    int randomInt = min + ran.nextInt(max - min + 1);
    
        
    17
    2019-02-08 14: 15: 11Z
    1. Nie widzę tu nic nowego, co nie zostało opublikowane w niezliczonych wcześniejszych postach.
      2017-06-19 21: 21: 53Z

    Kiedy potrzebujesz wielu liczb losowych, nie polecam klasy Random w API. Ma za mało czasu. Zamiast tego wypróbuj Mersenne twister . Jest implementacja Java .

        
    16
    2013-08-01 18: 02: 34Z
 
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);
}
    
16
2019-02-08 14: 15: 15Z

Inną opcją jest 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);
    // ...
 }
    
15
2018-04-23 05: 22: 28Z

Oto prosty przykład, który pokazuje, jak wygenerować losową liczbę z zamkniętego zakresu [min, max], a min <= max is true

Możesz użyć go ponownie jako pola w klasie otworów, mając również wszystkie Random.class metod 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;
    }
}
    
14
2014-11-28 00: 58: 54Z
  1. 2017-06-19 21: 21: 16Z

Lepiej jest użyć SecureRandom raczej niż tylko losowo.

 
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;
}
    
13
2016-07-06 19: 19: 36Z
  1. To nie jest tak dobre, ponieważ jeśli zostanie wykonane w tej samej milisekundie, otrzymasz ten sam numer, musisz umieścić inicjalizację rand i setSeet na zewnątrz metody.
    2015-04-16 19: 30: 54Z
  2. Potrzebujesz materiału siewnego, tak, ale używając SecureRandom.
    2015-04-17 12: 03: 36Z
  3. Przepraszam, ale ten, kto odrzucił prośbę o zmianę, nie ma pojęcia o programowaniu w Javie To dobra propozycja, ale jak to jest złe ponieważ jeśli zostanie wykonana w tej samej milisekundie, da ten sam numer, a nie losowo.
    2015-04-18 09: 19: 43Z
  4. Prawidłowego rozwiązania nie można nigdzie znaleźć, niewiele osób zna statyczne bloki inicjatora ... to jest to, czego powinieneś użyć do ustawienia nasion: 1: private static int SecureRandom rand = new SecureRandom(); 2: static { 3: rand.setSeed(...); 4: }
    2015-04-18 09: 30: 44Z
  5. Absolutnie nie ma potrzeby wysiewu SecureRandom, zostanie on obsadzony przez system. Bezpośrednie wywołanie setSeed jest bardzo niebezpieczne, może zastąpić (naprawdę losowe) ziarno datą. I na pewno nie skutkuje SecureRandom, ponieważ każdy może odgadnąć czas i spróbować zasiać swoją SecureRandom instancję tą informacją.
    2017-03-01 21: 32: 46Z
 
rand.nextInt((max+1) - min) + min;

To działa dobrze.

    
12
2016-04-21 06: 01: 59Z
źródło umieszczone tutaj