100 случайных чисел java

Rukovodstvo

статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.

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

Введение В этом руководстве мы рассмотрим, как сгенерировать случайные целые числа в определенном диапазоне в Java. Мы рассмотрим несколько подходов, включая базовые решения Java и сторонние решения: * Random.ints () * Random.nextInt () * Math.random () * SecureRandom.nextInt () * ThreadLocalRandom.nextInt () * SplittableRandom.ints () Примечание: для каждого подхода мы рассмотрим, как сгенерировать одно случайное целое число, а также как сгенерировать последовательность случайных целых чисел. Все эти методы

Вступление

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

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

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

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

Random.ints ()

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

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

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

 -526320702 -744603161 474879020 1864311422 406782252 . 

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

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

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

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

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

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

Чтобы сгенерировать одно случайное целое число, вы можете просто настроить первый аргумент метода 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 intsInRange(int size, int lowerBound, int upperBound) < Random random = new Random(); Listresult = new ArrayList<>(); for (int i = 0; i < size; i++) < result.add(random.nextInt(upperBound - lowerBound) + lowerBound); >return result; > 

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

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

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

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 intsInRange(int size, int lowerBound, int upperBound) < SecureRandom random = new SecureRandom(); Listresult = new ArrayList<>(); for (int i = 0; i < size; i++) < result.add(random.nextInt(upperBound - lowerBound) + lowerBound); >return result; > 

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

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

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 intsInRange(int size, int lowerBound, int upperBound) < Listresult = new ArrayList<>(); for (int i = 0; i < size; i++) < result.add((int)(Math.random() * (upperBound + 1 - lowerBound) + lowerBound)); >return result; > 

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

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

ThreadLocalRandom.nextInt ()

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

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

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

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

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

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

 List integerList = intsInRange4(5, 0, 10); System.out.println(integerList); [1, 9, 1, 9, 7] 

SplittableRandom.ints ()

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

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

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

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

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

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

Заключение

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

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

Licensed under CC BY-NC-SA 4.0

Источник

Генерация случайного числа в заданном диапазоне

Привет по ту сторону экрана. Любой из нас рано или поздно встречается с необходимостью генерировать случайное число в заданном нами диапазоне будь то вещественное или целое число. Для чего? На самом деле это не важно, это может быть функция для расчета шанса для запуска какого нибудь события, получение случайного множителя или любого другая. Итак, для чего это нужно разобрались, а именно для чего угодно 🙂 На самом деле методов получения псевдослучайного числа очень много, я же приведу пример с классом Math , а именно с методом random() ; Что же мы имеем? Вызов метода Math.random() возвращает псевдослучайное вещественное число ( double ) из диапазона [0;1) , то есть, от 0 до 1 исключая 1, а значит максимальное число в диапазоне это 0.99999999999. Хорошо, мы получили псевдослучайное число, но если нам нужен свой диапазон? К примеру, нам нужно псевдослучайное число из диапазона [0;100)? Пишем код:

 public static void main(String. args) < final double max = 100.; // Максимальное число для диапазона от 0 до max final double rnd = rnd(max); System.out.println("Псевдослучайное вещественное число: " + rnd); >/** * Метод получения псевдослучайного вещественного числа от 0 до max (исключая max); */ public static double rnd(final double max)

Получилось не плохо, но max (в нашем случае) мы все равно не получим. Для того чтобы получить случайное число в диапазоне [0;100] нам необходимо прибавить к нашему max 1, а затем преобразовать в целое число типа int или long (зависит от диапазонов которые Вы будете использовать). Пишем код:

 public static void main(String. args) < final int max = 100; // Максимальное число для диапазона от 0 до max final int rnd = rnd(max); System.out.println("Псевдослучайное целое число: " + rnd); >/** * Метод получения псевдослучайного целого числа от 0 до max (включая max); */ public static int rnd(int max)

Примечание: Как видите переменная max была инкрементирована префиксной формой. (Если Вы не знаете что это советую почитать мою статью) Отлично, мы получили то что хотели, но если нам нужен диапазон не от 0, а к примеру [10;75] Пишем код:

 public static void main(String. args) < final int min = 10; // Минимальное число для диапазона final int max = 75; // Максимальное число для диапазона final int rnd = rnd(min, max); System.out.println("Псевдослучайное целое число: " + rnd); >/** * Метод получения псевдослучайного целого числа от min до max (включая max); */ public static int rnd(int min, int max)

 Минимальное число диапазона = 10; Максимальное число диапазона = 75; max -= min; // Отнимаем от максимального значения минимальное для получения множителя псевдослучайного вещественного числа. 

Максимальное число после расчета равно 65 Псевдослучайное вещественное число (к примеру) равно 0.18283417347179454 (Был получен при вызове Math.random() ). Максимальное число перед умножением было инкрементировано префиксной формой. Максимальное число теперь 66 Умножаем 0.18283417347179454 на 66. Результат умножения равен 12.06705544913844. Преобразовываем результат умножения максимального числа на псевдослучайное вещественное число к типу целого числа int . Прибавляем минимальное число к преобразованному результату который равен 12. Возвращаем результат: 22 Как видно из разбора, даже если псевдослучайное вещественное число будет равно нулю, то мы вернем наш минимум в результате сложения нашего минимального числа с результатом умножения. Надеюсь для Вас это было полезно и познавательно. Успехов в освоении Java 😉 Еще пару моих статей: Что такое инкрементирование и декрементирование Оператор деления по модулю

Источник