Java: генерировать случайные целые числа в диапазоне

Вступление

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

Мы рассмотрим несколько подходов, включая базовую Java и сторонние решения:

Random.ints ()
Random.nextInt ()
Math.random ()
SecureRandom.nextInt ()
ThreadLocalRandom.nextInt ()
SplittableRandom.ints ()

Примечание. Для каждого подхода мы рассмотрим, как сгенерировать одно случайное целое число, а также как сгенерировать последовательность случайных целых чисел .

Все эти методы включают нижнюю границу и исключают верхнюю границу .

Random.ints ()

Мы начали с Random.ints() который был добавлен в Random в Java 8 именно для этой цели. Изначально в Java не было полностью интуитивно понятного , встроенного решения этой задачи.

Метод ints() возвращает последовательность случайных значений в форме IntStream . Будучи Stream , она неограниченна:

 Random random = new Random(); 
 random.ints().forEach(System.out::println);

Это приводит к:

Это неограниченный IntStream , который будет генерировать любое значение от Integer.MIN_VALUE до Integer.MAX_VALUE . Однако вы можете указать диапазон , а также количество элементов, которые вы хотите создать.

Кроме того, первый аргумент - это количество элементов, которые вы хотите сгенерировать - в противном случае поток будет генерировать неограниченное количество элементов, пока не закончится ваше пространство кучи:

 List<Integer> intList = new Random().ints(5, 1, 11) 
 .boxed() 
 .collect(Collectors.toList()); 
 
 System.out.println(intList);

Перед сбором IntStream нам придется упаковать его с помощью boxed() , который возвращает поток, состоящий из элементов IntStream , упакованных в Integer . Затем мы запускаем collect() в возвращенном потоке, а не в исходном.

Метод collect() объекта IntStream не возвращает коллекцию - он выполняет изменяемую операцию сокращения .

Выполнение этого кода приводит к:

 [1, 9, 9, 6, 2]

Чтобы сгенерировать одно случайное целое число, вы можете просто настроить первый аргумент метода ints() или использовать findFirst() и getAsInt() чтобы извлечь его из IntStream :

 int randomInt = new Random().ints(1, 1, 11).findFirst().getAsInt(); 
 System.out.println(randomInt);

Это приводит к случайному целому числу в диапазоне от 1..10 (второго аргумента является исключительным):

Random.nextInt ()

Более классический пример, который вы часто будете видеть, - это просто использование Random.nextInt() . Он принимает bound , который устанавливает верхнюю границу , а по умолчанию устанавливает нижнюю границу равной 0

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

 int min = 10; 
 int max = 100; 
 
 System.out.println(new Random().nextInt(max - min) + min);

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

Для генерации такой последовательности нам потребуется вызвать метод несколько раз:

 public static List<Integer> intsInRange(int size, int lowerBound, int upperBound) { 
 Random random = new Random(); 
 List<Integer> result = new ArrayList<>(); 
 for (int i = 0; i < size; i++) { 
 result.add(random.nextInt(upperBound - lowerBound) + lowerBound); 
 } 
 return result; 
 }

Это ограниченное List воссоздание функции Random.ints() , которая просто возвращает список случайно сгенерированных целых чисел в диапазоне с заданным размером:

 List<Integer> integerList = intsInRange(5, 0, 10); 
 System.out.println(integerList);

Запуск этого кода приведет к чему-то вроде:

 [3, 8, 2, 2, 9]

SecureRandom.nextInt ()

Класс SecureRandom является альтернативой классическому Random , но предоставляет криптографически стойкий генератор случайных чисел. Random изнутри полагается на системные часы для генерации начальных чисел, что не является на самом деле случайным.

С другой стороны, SecureRandom берет гораздо больше случайных данных из среды, чтобы сгенерировать гораздо более случайное начальное число.

Если вас беспокоит криптографическая безопасность, вы можете SecureRandom который ведет себя почти так же, как Random с точки зрения разработчика:

 int max = 100; 
 int min = 10; 
 
 int randomInt = new SecureRandom().nextInt(max - min) + min; 
 System.out.println(randomInt);

В результате получается случайное целое число в диапазоне от min до max :

А если вы хотите сгенерировать последовательности, можно создать вспомогательный метод:

 public static List<Integer> intsInRange(int size, int lowerBound, int upperBound) { 
 SecureRandom random = new SecureRandom(); 
 List<Integer> result = new ArrayList<>(); 
 for (int i = 0; i < size; i++) { 
 result.add(random.nextInt(upperBound - lowerBound) + lowerBound); 
 } 
 return result; 
 }

Что вы можете использовать как:

 List<Integer> integerList = intsInRange3(5, 0, 10); 
 System.out.println(integerList);

И в результате:

 [0, 9, 5, 6, 5]

Math.random ()

Класс Math предоставляет нам отличные вспомогательные методы, связанные с математикой. Одним из них является Math.random() метод, который возвращает случайное значение между 0..1 . Обычно он используется для генерации случайных значений процентилей.

Однако, аналогично Random.nextInt() - вы можете использовать эту функциональность для генерации любого целого числа в определенном диапазоне:

 int min = 10; 
 int max = 100; 
 
 int randomNumber = (int)(Math.random() * (max + 1 - min) + min); 
 System.out.println(randomNumber);

Хотя этот подход еще менее интуитивно понятен, чем предыдущий. Выполнение этого кода приводит к чему-то вроде:

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

 public static List<Integer> intsInRange(int size, int lowerBound, int upperBound) { 
 List<Integer> result = new ArrayList<>(); 
 for (int i = 0; i < size; i++) { 
 result.add((int)(Math.random() * (upperBound + 1 - lowerBound) + lowerBound)); 
 } 
 return result; 
 }

И тогда мы можем назвать это так:

 List<Integer> integerList = intsInRange(5, 0, 10); 
 System.out.println(integerList);

Что производит:

 [9, 0, 3, 2, 0]

ThreadLocalRandom.nextInt ()

Если вы работаете в многопоточной среде, ThreadLocalRandom предназначен для использования в качестве поточно-безопасного эквивалента Random . К счастью, он предлагает nextInt() метод как с верхней и нижней границы:

 int randomInt = ThreadLocalRandom.current().nextInt(0, 10); 
 System.out.println(randomInt);

Как обычно, нижняя граница включена, а верхняя - нет:

Точно так же вы можете создать вспомогательную функцию для генерации их последовательности:

 public static List<Integer> intsInRange(int size, int lowerBound, int upperBound) { 
 List<Integer> result = new ArrayList<>(); 
 for (int i = 0; i < size; i++) { 
 result.add(ThreadLocalRandom.current().nextInt(lowerBound, upperBound)); 
 } 
 return result; 
 }

Что вы можете использовать как:

 List<Integer> integerList = intsInRange4(5, 0, 10); 
 System.out.println(integerList); 

 [1, 9, 1, 9, 7]

SplittableRandom.ints ()

Менее известным классом в Java API является SplittableRandom который используется в качестве генератора псевдослучайных значений. Как следует из названия, он разделяется и работает параллельно, и на самом деле используется только тогда, когда у вас есть задачи, которые можно снова разделить на более мелкие подзадачи.

Стоит отметить, что этот класс также основан на незащищенной генерации семян - если вы ищете безопасную генерацию семян, используйте SecureRandom .

Класс предлагает ints() , который, с нашей точки зрения, работает так же, как Random.ints() :

 List<Integer> intList = new SplittableRandom().ints(5, 1, 11) 
 .boxed() 
 .collect(Collectors.toList()); 
 
 System.out.println(intList);

Что приводит к:

 [3, 2, 8, 10, 3]

И, если вы хотите сгенерировать только одно случайное число, вы можете отказаться от сборщика и использовать findFirst() с getAsInt() :

 int randomInt = new SplittableRandom().ints(1, 1, 11).findFirst().getAsInt(); 
 System.out.println(randomInt);

Что приводит к:

Заключение

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

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