Целые числа java random

Java: Генерация случайных целых чисел в диапазоне

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

Вступление

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

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

• Случайные.ints()
• Случайный.nextInt()
• Математика.случайная()
• SecureRandom.nextInt()
• ThreadLocalRandom.nextInt()
• SplittableRandom.ints()

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

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

Случайные.ints()

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

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

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

-526320702 -744603161 474879020 1864311422 406782252 .

Это неограниченный поток , который будет генерировать любое значение из целого числа.МИНИМАЛЬНОЕ ЗНАЧЕНИЕ в Целое число.МАКСИМАЛЬНОЕ ЗНАЧЕНИЕ . Однако вы можете указать диапазон , а также количество элементов , которые вы хотели бы сгенерировать.

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

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

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

collect() метод IntStream не возвращает коллекцию – он выполняет операцию изменяемого сокращения .

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

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

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

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

Случайный.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; > 

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

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

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

SecureRandom.nextInt()

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

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

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

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

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

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

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

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 предоставляет нам отличные вспомогательные методы, связанные с математикой. Одним из них является метод 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); 

SplittableRandom.ints()

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

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

Класс предлагает метод init () , который, с нашей точки зрения, работает так же, как 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 .

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

Читайте ещё по теме:

Источник

Class Random

An instance of this class is used to generate a stream of pseudorandom numbers; its period is only 2 48 . The class uses a 48-bit seed, which is modified using a linear congruential formula. (See Donald E. Knuth, The Art of Computer Programming, Volume 2, Third edition: Seminumerical Algorithms , Section 3.2.1.)

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers. In order to guarantee this property, particular algorithms are specified for the class Random . Java implementations must use all the algorithms shown here for the class Random , for the sake of absolute portability of Java code. However, subclasses of class Random are permitted to use other algorithms, so long as they adhere to the general contracts for all the methods.

The algorithms implemented by class Random use a protected utility method that on each invocation can supply up to 32 pseudorandomly generated bits.

Many applications will find the method Math.random() simpler to use.

Instances of java.util.Random are threadsafe. However, the concurrent use of the same java.util.Random instance across threads may encounter contention and consequent poor performance. Consider instead using ThreadLocalRandom in multithreaded designs.

Instances of java.util.Random are not cryptographically secure. Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.

Источник

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

Привет по ту сторону экрана. Любой из нас рано или поздно встречается с необходимостью генерировать случайное число в заданном нами диапазоне будь то вещественное или целое число. Для чего? На самом деле это не важно, это может быть функция для расчета шанса для запуска какого нибудь события, получение случайного множителя или любого другая. Итак, для чего это нужно разобрались, а именно для чего угодно 🙂 На самом деле методов получения псевдослучайного числа очень много, я же приведу пример с классом 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 😉 Еще пару моих статей: Что такое инкрементирование и декрементирование Оператор деления по модулю

Источник