64 Вопрос: Как генерировать случайные целые числа в определенном диапазоне в Java?

вопрос создан в Sat, Jan 5, 2019 12:00 AM

Как создать случайное значение int в определенном диапазоне?

Я пробовал следующее, но они не работают:

Попытка 1:

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

Попытка 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 ответов                              30                         

В Java 1.7 или более поздней версии стандартный способ сделать это заключается в следующем:

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

См. соответствующий JavaDoc . Преимущество этого подхода заключается в том, что нет необходимости явно инициализировать экземпляр java.util.Random , который может стать источником путаницы и ошибок при неправильном использовании.

Однако, наоборот, нет способа явно установить начальное число, поэтому может быть трудно воспроизвести результаты в ситуациях, когда это полезно, таких как тестирование или сохранение состояний игры или тому подобное. В этих ситуациях может использоваться методика до Java 1.7, показанная ниже.

До Java 1.7 стандартный способ сделать это:

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

Смотрите соответствующий JavaDoc . На практике java Класс .util.Random часто предпочтительнее, чем java.lang.Math.random () .

В частности, нет необходимости заново изобретать колесо генерации случайных целых чисел, когда в стандартной библиотеке имеется простой API для выполнения задачи.

    
3591
2018-10-14 17: 08: 35Z
  1. Для вызовов, у которых значение max равно Integer.MAX_VALUE, возможно переполнение, что приводит к java.lang.IllegalArgumentException. Вы можете попробовать с: randInt(0, Integer.MAX_VALUE).6250, также как и большинство, если значение 06003, то можно получить максимальное значение 06003 (0). довольно редко, я полагаю) не будет ли он снова переполнен (если min и max достаточно высокие значения)? Как бороться с такими ситуациями?
    2014-08-12 10: 34: 30Z
  2. Это не работает долгое время
    2015-02-23 06: 26: 46Z
  3. @ MoisheLipsker Должно быть, что nextLong не принимает границу как nextInteger
    2015-06-17 18: 42: 57Z
  4. @ leventov nextInt((max-min) + 1) был добавлен в Java через 2 с половиной года после того, как этот вопрос был впервые задан. Я всегда твердо придерживался мнения, что управление экземпляром Random находится за рамками вопроса.
    2015-09-11 01: 57: 18Z
  5. В Android Random rand = new Random ();
    2016-10-03 19: 55: 05Z

Обратите внимание, что этот подход является более предвзятым и менее эффективным, чем подход ThreadLocalRandom, https://stackoverflow.com/a/738651/360211 р>

Один стандартный шаблон для достижения этой цели:

nextInt

Java функция библиотеки Math Math.random () генерирует двойное значение в диапазоне

Min + (int)(Math.random() * ((Max - Min) + 1))
. Обратите внимание на этот раNGE не включает 1.

Чтобы сначала получить определенный диапазон значений, необходимо умножить его на величину диапазона значений, который вы хотите охватить.

[0,1)

Возвращает значение в диапазоне

Math.random() * ( Max - Min )
, где значение Max-Min не включено.

Например, если вы хотите [0,Max-Min), вам нужно указать пять целочисленных значений, чтобы вы использовали

[5,10)

Это вернет значение в диапазоне

Math.random() * 5
, где 5 не включено.

Теперь вам нужно сместить этот диапазон до диапазона, на который вы нацеливаетесь. Вы делаете это, добавляя значение Min.

[0,5)

Теперь вы получите значение в диапазоне

Min + (Math.random() * (Max - Min))
. Следуя нашему примеру, это означает [Min,Max): [5,10)

Но это по-прежнему не включает

5 + (Math.random() * (10 - 5))
, и вы получаете двойное значение. Чтобы получить включенное значение Max, необходимо добавить 1 к параметру диапазона Max и затем усечь десятичную часть путем приведения к типу int. Это достигается с помощью: (Max - Min)

И вот, у тебя это есть. Случайное целочисленное значение в диапазоне

Min + (int)(Math.random() * ((Max - Min) + 1))
или, например, [Min,Max]: [5,10]     
1383
2019-02-08 14: 13: 34Z
  1. В документации Sun явно сказано, что вам лучше использовать Random (), если вам нужно использовать int вместо Math.random (), который производит double.
    2012-02-23 23: 26: 34Z
  2. Это на самом деле смещение по сравнению с методами nextInt stackoverflow.com/a/738651 /360211
    2016-12-29 13: 35: 53Z

Использование:

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

Целое число

Random ran = new Random();
int x = ran.nextInt(6) + 5;
теперь является случайным числом, которое имеет возможный результат x.     
338
2019-02-08 14: 14: 20Z

Использование:

5-10     
143
2014-06-22 22: 22: 52Z

С они ввели метод

minimum + rn.nextInt(maxValue - minvalue + 1)
в ints(int randomNumberOrigin, int randomNumberBound) классе. . /р>

Например, если вы хотите сгенерировать пять случайных целых (или одно) в диапазоне [0, 10], просто выполните:

Random

Первый параметр указывает только размер сгенерированного

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
(который является перегруженным методом того, который генерирует неограниченное число IntStream).

Если вам нужно сделать несколько отдельных вызовов, вы можете создать бесконечный примитивный итератор из потока:

IntStream

Вы также можете сделать это для значений

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

Надеюсь, это поможет! :)

    
118
2019-02-08 14: 14: 56Z
  1. Я бы посоветовал вам создать экземпляр randomIterator только один раз. См. Грег Кейс, комментирующий его собственный ответ.
    2018-02-26 07: 13: 43Z
  2. если вы можете, можете ли вы объяснить, в чем смысл long - первый параметр этого метода задан streamSize. Какая разница, если задано streamSize !=0 1/2 /n?
    2018-04-10 10: 39: 40Z

Вы можете отредактировать свой второй пример кода следующим образом:

streamSize     
100
2019-02-08 13: 02: 02Z

Подойдет только небольшая модификация вашего первого решения.

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

Подробнее о реализации

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

    
97
2019-02-08 14: 14: 29Z
  1. Для минимального значения < = value < максимум, я сделал то же самое с Math: randomNum = минимум + (int) (Math.random () * (максимум-минимум)); но на самом деле не очень приятно видеть кастинг;)
    2016-07-08 12: 30: 15Z

    ThreadLocalRandom эквивалент класса java.util.Random для многопоточной среды. Генерация случайного числа осуществляется локально в каждом из потоков. Таким образом, мы имеем лучшую производительность за счет уменьшения конфликтов.

    Random

    x, y - интервалы, например (1,10) р>     

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

    Класс

    int rand = ThreadLocalRandom.current().nextInt(x,y);
    
    в Java основан на 0. Итак, если вы напишите что-то вроде этого: Math.Random

    Random rand = new Random();
    int x = rand.nextInt(10);
    
    будет между x включительно.

    Итак, учитывая следующий массив из 0-9 элементов, код для генерации случайного числа между 25 (основание массива) и 0 будет следующим:

    array.length

    Поскольку

    String[] i = new String[25];
    Random rand = new Random();
    int index = 0;
    
    index = rand.nextInt( i.length );
    
    вернет i.length, 25 вернет число в диапазоне от nextInt( i.length ). Другой вариант работает с 0-24, который работает аналогичным образом. Math.Random

    Для лучшего понимания просмотрите сообщение на форуме Случайные интервалы (archive.org) .

        
    61
    2019-02-08 14: 14: 25Z
    1. + 1 для ссылки на скриншот архива wayBackMachine & Ваш ответ по-прежнему полезен для получения «случайных» целых значений в диапазоне.
      2016-10-30 05: 44: 57Z
    2. Это сбивает с толку меня, почему вы создаете экземпляр индекса в 0.
      2017-08-02 13: 53: 53Z
    3. @ CodeConfident Переменная
      index = (int) Math.floor(Math.random() * i.length);
      
      не повлияет на результат случайного числа. Вы можете инициализировать его любым удобным для вас способом, не беспокоясь об изменении результата. Надеюсь, это поможет.
      2017-08-02 14: 38: 52Z
    4. Точно ... он полностью не используется. Я бы инициализировал его прямо к rand: index
      2017-08-02 14: 41: 09Z

    Прости меня за привередливость, но решение, предложенное большинством, то есть int index = rand.nextInt(i.Length);, кажется опасным из-за того, что:

    • min + rng.nextInt(max - min + 1)) не может достичь rng.nextInt(n).
    • Integer.MAX_VALUE может вызвать переполнение, если значение (max - min) отрицательное.

    Надежное решение вернет правильные результаты для любого min в пределах [min <= max, Integer.MIN_VALUE]. Рассмотрим следующую наивную реализацию:

    Integer.MAX_VALUE

    Хотя это неэффективно, обратите внимание, что вероятность успеха в цикле

    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;
    }
    
    всегда будет 50% или выше.     
    48
    2018-04-23 05: 21: 33Z
    1. Почему бы не вызвать исключение IllegalArgumentException, если разница = Integer.MAX_VALUE? Тогда вам не нужен цикл while.
      2015-01-09 10: 27: 57Z
    2. @ mpkorstanje Эта реализация предназначена для работы с любыми значениями min < = max, даже когда их разность равна или даже больше, чем MAX_VALUE. Выполнение цикла до достижения успеха в этом случае является обычной моделью, гарантирующей равномерное распределение (если основной источник случайности является однородным). Random.nextInt (int) делает это внутренне, когда аргумент не является степенью 2.
      2015-05-06 19: 27: 30Z

    Интересно, есть ли какой-либо из методов генерации случайных чисел, предоставляемый Apache Commons Math Библиотека будет отвечать всем требованиям.

    Например: while или RandomDataGenerator.nextInt

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

    Это можно сделать, просто выполнив инструкцию:

    RandomDataGenerator.nextLong

    Ниже приведен его исходный код

    Randomizer.java

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

    Это просто чисто и просто.

        
    31
    2019-03-03 14: 29: 04Z
    1. Это могло бы быть изменение другого примера, теперь это просто вопиющая копия репутации. Указание «ответа большинством голосов» также не очень прямое, оно может измениться.
      2017-06-19 21: 23: 47Z
    2. Это верно @MaartenBodewes. Когда я писал этот ответ, ответ с большинством голосов выше все еще был написан в виде алгоритмического решения. Теперь решение, приведенное выше, сильно изменилось, и теперь этот ответ выглядел как подражатель.
      2017-06-20 00: 36: 07Z

    Давайте возьмем пример.

    Предположим, я хочу сгенерировать число в диапазоне 5-10 :

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

    Дайте нам понять это ...

      
        

    Инициализируйте max максимальным значением, а min минимальным.

             

    Теперь нам нужно определить, сколько возможных значений можно получить. Для этого примера это будет:

             
          

    5, 6,7, 8, 9, 10

        
             

    Таким образом, число будет максимум - мин + 1.

             
          

    то есть. 10 - 5 + 1 = 6

        
             

    Случайное число будет генерировать число в диапазоне от 0-5 .

             
          

    то есть. 0, 1, 2, 3, 4, 5

        
             

    Добавление значения min к случайному числу приведет к получению:

             
          

    5, 6, 7, 8, 9, 10

        
             

    Следовательно, мы получаем желаемый диапазон.

      
        
    30
    2019-02-08 14: 14: 10Z
    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);
    
        
    27
    2017-12-20 19: 34: 30Z

    Создайте случайное число для разницы min и max, используя nextint (n) , а затем добавьте минимальный номер к результату:

     rand.nextInt((max+1) - min) + min;
    
        
    22
    2019-02-08 14: 15: 07Z
      

    Начиная с Java 7, вы больше не должны использовать

    Random rn = new Random();
    int result = rn.nextInt(max - min + 1) + min;
    System.out.println(result);
    
    . В большинстве случаев   генератор случайных чисел выбора сейчас    Random .

    Для вилочных и параллельных пулов   потоки, используйте ThreadLocalRandom . >

    Джошуа Блох. Эффективная Java. Третье издание.

    Начиная с Java 8

    Для пулов разветвления и параллельных потоков используйте SplittableRandom, который обычно быстрее, обладает лучшими свойствами статистической независимости и однородности по сравнению с SplittableRandom.

    Для генерации случайного Random в диапазоне int

    [0, 1_000]:

    Создать случайный массив значений

    int n = new SplittableRandom().nextInt(0, 1_001);
    
    в диапазоне int[100] [0, 1_000]:

    Чтобы вернуть поток случайных значений:

    int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
    
        
    21
    2019-02-08 08: 56: 49Z
    1. Есть ли причина, по которой в примере используется
      IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
      
      ? Мне кажется, что генерация 100 случайных чисел была бы слишком тривиальной, чтобы оправдать параллелизм.
      2018-07-20 06: 29: 12Z
    2. @ Johnbot Спасибо за комментарий, вы правы. Но основной причиной было показать API (конечно, разумный путь - это измерить производительность перед использованием обработки .parallel()). Кстати, для массива элементов parallel версия 1_000_000 на моей машине была в 2 раза быстрее по сравнению с последовательной.
      2018-07-20 08: 35: 20Z

    Вот полезный класс для генерации случайного parallel в диапазоне с любой комбинацией включающих /исключающих границ:

    ints     
    19
    2012-02-15 16: 19: 03Z

    В случае броска кубика это будет случайное число от 1 до 6 (не от 0 до 6), поэтому:

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

    Чтобы сгенерировать случайное число «между двумя числами», используйте следующий код:

    face = 1 + randomNumbers.nextInt(6);
    

    Это дает вам случайное число от 1 (включительно) до 11 (исключение), поэтому инициализируйте значение upperBound, добавив 1. Например, если вы хотите сгенерировать случайное число от 1 до 10, инициализируйте число upperBound с помощью 11 вместо 10.

        
    19
    2019-02-08 14: 09: 12Z
    Random r = new Random();
    int lowerBound = 1;
    int upperBound = 11;
    int result = r.nextInt(upperBound-lowerBound) + lowerBound;
    

    Или посмотрите на RandomUtils из Apache Commons .

        
    19
    2019-02-08 14: 11: 23Z
    1. Это полезно, но остерегайтесь небольшого недостатка: сигнатуры методов выглядят следующим образом: nextDouble (double startInclusive, double endInclusive), но если вы загляните внутрь методов, endInclusive на самом деле должно быть EndExclusive.
      2015-01-30 09: 27: 17Z
    2. int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
      
      - довольно запутанный (и неэффективный) способ сказать Double.valueOf(Math.random()*(maximum-minimun)).intValue()
      2016-06-03 09: 47: 15Z
    3. Несоответствие правописания для минимального минимума возврата + Double.valueOf (Math.random () * (максимум - минимум)). intValue ();
      2016-12-26 05: 14: 23Z

    Эти методы могут быть удобны в использовании:

    Этот метод возвращает случайное число между указанным значением min и max:

    (int)(Math.random()*(maximum-minimun))

    и этот метод вернет случайное число из указанного минимального и максимального значения (поэтому сгенерированное число также может быть минимальным или максимальным числом):

    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;
        }
    }
    
        
    19
    2019-02-08 14: 14: 37Z
    1. public static int getRandomNumberFrom(int min, int max) {
          Random foo = new Random();
          int randomNumber = foo.nextInt((max + 1) - min) + min;
      
          return randomNumber;
      }
      
      . Зачем? Мин не считается? Обычно диапазон составляет [min, max), где min включено, а max исключено. Неправильный ответ, проголосовал вниз.
      2017-03-01 21: 26: 35Z
    2. @ MaartenBodewes +1 добавлено, потому что getRandomNumberBetween генерирует случайное число, исключая предоставленные конечные точки.
      2017-03-02 09: 53: 53Z
    3. Число // Since the random number is between the min and max values, simply add 1 будет в два раза чаще, чем другое число, которое будет результатом min + 1!
      2018-06-17 12: 21: 50Z

    Вы можете достичь этого кратко в Java 8:

    getRandomNumberBetween     
    17
    2019-02-08 14: 14: 15Z

    Я нашел этот пример Создать случайные числа .

    Этот пример генерирует случайные целые числа в определенном диапазоне.

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

    Пример запуска этого класса:

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

    Просто используйте класс Random

    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: 15: 11Z
    1. Я не вижу здесь ничего нового, что не было опубликовано в бесчисленных предыдущих сообщениях.
      2017-06-19 21: 21: 53Z

    Когда вам нужно много случайных чисел, я не рекомендую случайный класс в API. У него слишком маленький период. Попробуйте вместо этого тварь Мерсенна . Существует реализация Java .

        
    16
    2013-08-01 18: 02: 34Z
    Random ran = new Random();
    // Assumes max and min are non-negative.
    int randomInt = min + ran.nextInt(max - min + 1);
    
        
    16
    2019-02-08 14: 15: 15Z

    Другой вариант - просто использовать Apache Commons :

    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
    2018-04-23 05: 22: 28Z

    Вот простой пример, который показывает, как генерировать случайное число из закрытого диапазона

    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);
        // ...
     }
    
    , в то время как [min, max]

    Вы можете повторно использовать его как поле в классе отверстия, также имея все методы min <= max is true в одном месте

    Пример результатов:

    Random.class

    Источники:

    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
    
        
    14
    2014-11-28 00: 58: 54Z
    1. 2017-06-19 21: 21: 16Z

    Лучше использовать SecureRandom чем просто случайный.

    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
    2016-07-06 19: 19: 36Z
    1. Это не так хорошо, потому что, если он выполняется за одну и ту же миллисекунду, вы получите то же число, вам нужно поместить инициализацию rand и setSeet вне метода.
      2015-04-16 19: 30: 54Z
    2. Да, нужно использовать seed, но с использованием SecureRandom.
      2015-04-17 12: 03: 36Z
    3. Извините, но тот, кто отклонил запрос на изменение, не имеет ни малейшего представления о программировании на Java Это хорошее предложение, но оно неверно потому что при выполнении за одну и ту же миллисекунду он даст одинаковое число, а не случайное.
      2015-04-18 09: 19: 43Z
    4. Правильное решение нигде не найдено, немногие знают блоки статической инициализации ... это то, что вы должны использовать для установки начального числа: 1:
      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;
      }
      
      2: private static int SecureRandom rand = new SecureRandom(); 3: static { 4: rand.setSeed(...);
      2015-04-18 09: 30: 44Z
    5. Абсолютно не нужно заполнять }, он будет посеян системой. Прямой вызов SecureRandom очень опасен, он может заменить (действительно случайное) начальное число датой. И это, безусловно, не приведет к setSeed, так как любой может угадать время и попытаться засеять свой экземпляр SecureRandom этой информацией.
      2017-03-01 21: 32: 46Z
    SecureRandom

    Это работает нормально.

        
    12
    2016-04-21 06: 01: 59Z
    rand.nextInt((max+1) - min) + min;
    
источник размещен Вот