В основном он вводит три метода получения случайных чисел в Java, в основном с использованием функции random () для ее реализации
Метод 1
(Тип данных) (минимальное значение + math.random ()*(максимальное значение -minimum value +1)) Пример:
(int) (1+math.random ()*(10-1+1))
Int тип от 1 до 10
Метод 2
Получить случайное число
for (int i = 0; i <30; i ++) {System.out.println ((int) (1+math.random ()*10));} (int) (1+math.random ()*10) Случайный метод пакета java.math получает случайное число INT 1-10
Формула: минимальное значение ---- Случайное количество максимального значения (интеграл)
(Тип) min + math.random () * максимальное значение
Метод 3
Случайный ra = new random (); для (int i = 0; i <30; i ++) {System.out.println (ra.nextint (10) +1);} Используйте метод случайного класса nextint в пакете java.util, чтобы получить случайное число int 1-10
Генерируйте любые случайные десятичные десятики от 0 до 1:
Чтобы сгенерировать случайное десятичное значение в интервале [0, D), а D - любая положительная десятичная десятичная, вам нужно только умножить возвратное значение следующего метода на D.
[N1, N2]
То есть ra.nextdouble () * (n2-n1)+n1
Несколько способов генерировать случайные числа на Java
1. В J2SE мы можем использовать метод Math.Random () для генерации случайного числа. Сгенерированное случайное число-это двойное между 0-1. Мы можем умножить его на определенное число, например, умножить на 100. Это случайно в пределах 100, чего не существует в J2ME.
2. В пакете java.util предоставляется случайный класс. Мы можем создать новый случайный объект для генерации случайных чисел. Он может генерировать случайные целые числа, случайные поплавки, случайные удвоения и случайные длинные. Это также метод приема случайных чисел, которые мы часто используем в программах J2ME.
3. В нашем системном классе есть метод CurrentTimemillis (). Этот метод возвращает миллисекундное число с 0:00:00 1 января 1970 года в текущий. Возвратный тип длинный. Мы можем использовать его в качестве случайного числа. Мы можем использовать его для модуля некоторых чисел и ограничить его диапазоном.
Фактически, в методе по умолчанию Random по умолчанию третий метод выше используется для генерации случайных чисел.
Случайный класс во втором методе имеет следующее описание:
Есть два способа построить java.util.random Class: с семенами и без семян
Нет семян:
Этот метод будет возвращать случайные числа, и результаты будут разными для каждого запуска.
открытый класс случайный {public static void main (string [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ());}} С семенами:
Таким образом, независимо от того, сколько раз работает программа, результат возврата будет таким же
public static void main (string [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ());}} Разница между двумя методами состоит
(1) Во -первых, откройте Java Doc, мы увидим описание случайного класса:
Примеры этого класса используются для генерации псевдолупиточных потоков, которые используют 48-битное семя, которое можно изменить с использованием линейной конгруэнтной формулы.
Если два случайных экземпляра создаются с одним и тем же семенем, в каждом экземпляре производится одна и та же последовательность вызовов методов, и они будут генерировать и возвращать одну и ту же последовательность чисел. Чтобы обеспечить реализацию этой функции, мы указываем конкретный алгоритм для случайного класса. Для полной переносимости кода Java реализации Java должны иметь класс случайным образом использовать все алгоритмы, показанные здесь. Но подклассам случайного класса разрешено использовать другие алгоритмы, если они соответствуют обычным соглашениям всех методов.
Java Doc очень хорошо объяснил случайный класс, и наши тесты подтвердили это.
(2) Если число семян не предоставлено, количество семян случайного экземпляра будет миллисекундами текущего времени. Вы можете получить миллисекунды текущего времени через System.currentTimeMillis (). Откройте исходный код JDK, и мы можем увидеть это очень четко.
public random () {this (System.currentTimeMillis ()); } кроме того:
Описание методов nextint (), nextint (int n) случайного объекта:
int nextint () // Возвращает следующее псевдо-рэндовое число, которое представляет собой равномерно распределенное значение int в последовательности этого генератора случайных чисел.
int nextint (int n) // Возвращает псевдолупительное число, которое представляет собой значение int, равномерно распределенное между 0 (включая), и указанное значение (исключая), взятое из последовательности этого генератора случайных чисел.
Java Random Number Support
Случайные числа широко используются на практике, такие как генерация строки или числа с фиксированной длиной. Либо тогда генерируйте ряд неопределенной длины, либо выполните моделируемый случайный выбор и т. Д. Java предоставляет самые основные инструменты, которые могут помочь разработчикам достичь всего этого.
1. Как генерировать случайные числа Java
В Java есть три общих понятия случайных чисел.
1. Используйте System.currentTimeMillis (), чтобы получить количество миллисекундов длинного типа в настоящее время.
2. Верните двойное значение от 0 до 1 через математику.random ().
3. Сгенерировать случайное число через случайный класс. Это профессиональный случайный класс инструментов с мощными функциями.
2. Случайное описание API
1. Описание Java API
Экземпляр случайного класса используется для генерации псевдо-рэндового потока числа. В этом классе используются 48-битные семена и используют линейную конгруэнтную формулу для их изменения (см. Дональд Кнут «Искусство компьютерного программирования», том 2, раздел 3.2.1).
Если два случайных экземпляра создаются с одним и тем же семенем, в каждом экземпляре производится одна и та же последовательность вызовов методов, и они будут генерировать и возвращать одну и ту же последовательность чисел. Чтобы обеспечить реализацию атрибутов, определенный алгоритм указан для случайного класса.
Многие приложения найдут случайный метод в классе математики проще в использовании.
2. Сводка метода
Random () // Создать новый генератор случайных чисел.
Случайный (длинные семена) // Создать новый генератор случайных чисел с использованием одного длинного семени: public random (long Seed) {setseed (Seed); } Следующий метод использует его для сохранения состояния генератора случайных чисел.
Защищенный int Далее (int bits): генерирует следующее псевдо-рэндовое число.
Boolean nextboolean (): возвращает следующее псевдо-рэндовое число, которое представляет собой равномерно распределенное логическое значение, взятое из последовательности этого генератора случайных чисел.
void nextbytes (байт [] байты): генерирует случайные байты и помещает их в предоставленную пользователя байт.
Double NextDouble (): возвращает следующее псевдо-рэндовое число, которое представляет собой двойное значение, равномерно распределенное между 0,0 и 1,0, взятое из последовательности этого генератора случайных чисел.
float nextfloat (): возвращает следующее псевдолупительное число, которое представляет собой поплавское значение, равномерно распределено от 0,0 до 1,0, взятых из последовательности этого генератора случайных чисел.
Double NextGaussian (): возвращает следующее псевдо-рэндовое число, которое представляет собой гауссовое («нормально») распределение, взятое из последовательности этого генератора случайных чисел, со средним значением 0,0 и стандартным отклонениями 1,0.
int nextInt (): возвращает следующее псевдолупительное число, которое представляет собой равномерно распределенное значение int в последовательности этого генератора случайных чисел.
int nextint (int n): возвращает псевдо-рэндовое число, которое представляет собой равномерно распределенное значение int, взятое из последовательности этого генератора случайных чисел и равномерно распределено между 0 (включая) и указанным значением (исключая).
long nextlong (): возвращает следующее псевдолупительное число, которое представляет собой равномерно распределенное длительное значение, взятое из последовательности этого генератора случайных чисел.
void eleceed (длинное семя): устанавливает семена этого генератора случайных чисел с использованием одного длинного семени.
3. Инструкции по использованию случайных классов
1. Разница между получением семян и не взятым семенами. Фундаментальное использование случайного класса заключается в разделении примеров случайных с семенами и без семян.
С точки зрения непрофессионала, разница между ними состоит в том, чтобы: если семена производятся, результаты, полученные с каждым прогоном, одинаковы.
Если у вас нет семян, то, что вы генерируете, случайно каждый раз, когда вы запускаете, и нет никакого рисунка вообще.
2. Создайте случайный объект без семян
Случайный случайный = new Random ();
3. Есть два способа создания случайного объекта без семян:
1) случайный случайный = новый случайный (555L);
2) случайный случайный = new Random (); random.Seteed (555L);
4. Тест
Используйте пример, чтобы проиллюстрировать использование выше
импортировать java.util.random; открытый класс testrandomnum {public static void main (string [] args) {randomTest (); тест (); TesteD1 (); tested2 (); } public static void randomTest () { System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- long R1 = CurrentTimemillis (); System.out.println ("r2 =" + r3); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Random(); for (int i = 0; i <3; i ++) {System.out.println (random.nextint ()); }} public static void testseed1 () { System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Результаты работы:
--------------тест()--------------
R1 = 1227108626582
R3 = 0,5324887850155043
R2 = -368083737
-------------- Testnoseed () ---------------
809503475
1585541532
-645134204
-------------- testseed1 () ---------------
-1367481220
292886146
-1462441651
-------------- TestSeed2 () ---------------
-1367481220
292886146
-1462441651
Процесс завершен с кодом выхода 0
Благодаря результатам методов TestSeed1 () и TestSeed2 () мы видим, что два результата печати одинаковы, потому что они видят то же самое. Если они заберутся снова, результат будет все равно. Это характерно случайных чисел с семенами. Если у вас нет семян, результаты каждого прогона являются случайными.
V. Комплексное применение
Ниже приведено недавно написанный класс инструментов случайных чисел, чтобы показать использование:
импортировать java.util.random; Public Class randomutils {public Static Final String Allchar = "0123456789AbcdefghijklmnopqrStuvwxyzabcdefghijklmnopqrstuvwxyz"; Общественная статическая финальная строка itledchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; Public Static Final String number chorm = "0123456789"; public Static String Generatestring (int length) {stringBuffer sb = new StringBuffer (); Случайный случайный = new Random (); for (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (allchar.length ()))); } вернуть sb.toString (); } public Static String GenerateMixString (int length) {StringBuffer sb = new StringBuffer (); Случайный случайный = new Random (); for (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (itmerchar.length ()))); } вернуть sb.toString (); } public static String GeneratelowerString (int length) {return generateMixString (длина) .tolowerCase (); } public Static String GenerateUpperString (int length) {return generateMixString (длина) .toupperCase (); } public Static String GenerateZerString (int length) {StringBuffer SB = new StringBuffer (); for (int i = 0; i <length; i ++) {sb.append ('0'); } вернуть sb.toString (); } public static String tofixdlengthString (long num, int fixdlenth) {stringBuffer sb = new StringBuffer (); String strnum = string.valueof (num); if (fixdlenth - strnum.length ()> = 0) {sb.append (GeneratezerString (fixdlenth - strnum.length ())); } else {бросить новое runtimeexception ("преобразовать номер" + num + "Исключение возникает, когда исключение создается в строку с длиной" + fixdletne + ");} sb.append (strnum); return sb.toString ();} public Static String tofixdLengthString (int num, int fixdlenth) {stringBuffer stringbuffning (int num, int fixdlenth) {stringBuffer stringBuffning (int num, int fixdlenth) {stringbuffer sbringbuffrning (int num, int fixdlenth) {stringbuffer stringbuffns String.valueof (num); } sb.append (strnum); вернуть sb.toString (); } public static void main (string [] args) {System.out.println (Generatestring (15)); System.out.println (GenerateMixString (15)); System.out.println (GeneratelowerString (15)); System.out.println (GenerateUpperString (15)); System.out.println (GeneratezerString (15)); System.out.println (tofixdlengthstring (123, 15)); System.out.println (tofixdlengthstring (123L, 15)); System.out.println (tofixdlengthstring (123L, 15)); }}Результаты работы:
vwmbpinbzfgcphg
23hyrahdjkkpwmv
tigowetbwkm1nde
Bpz1knejphb115n
00000000000000000000
00000000000000123
00000000000000123
Процесс завершен с кодом выхода 0
6. Резюме
1. Случайные числа очень часто используются. Есть три способа создать их на Java. Случайные случайные числа являются наиболее сложными.
2. Случайные классовые объекты имеют разницу между тем, несут ли они семена. Пока семена одинаковы, они работают несколько раз, а результат генерации случайных чисел всегда одинаковы.
3. Есть два способа создания семян -объектов со случайными числами, с тем же эффектом. Но случайные числа с семенами, похоже, не имеют особого использования.
4. Функции случайного охватывают функции Math.random ().
5. Вы можете использовать случайные числа для реализации сложных случайных данных, таких как случайные строки.
6. Не изучайте случайные числа, которые не повторяются, это не очень значимо.
В Java мы можем использовать класс java.util.random для генерации случайных чисел. Он имеет две формы конструкторов, а именно случайные () и случайные (длинные семена). Random () использует текущее время, System.currentTimeMillis (), в качестве семян генератора, и случайный (длинное семя) использует указанное семя в качестве семян генератора.
После создания объекта генератора случайных чисел (случайного), различные типы случайных чисел получают путем вызова различных методов: nextint (), nextlong (), nextfloat (), nextdouble () и т. Д.
1> генерировать случайные числа
Случайный случайный = new Random (); Случайный случайный = новый случайный (100); // указать количество семян 100
Случайные вызовы различные методы для получения случайных чисел.
Если 2 случайных объекта используют одно и то же семя (например, оба составляют 100), а одна и та же функция вызывается в одном и том же порядке, то их возвратные значения точно одинаковы. Как и в следующем коде, вывод двух случайных объектов точно такой же
Импорт java.util.*; Class Testrandom {public static void main (string [] args) {случайный случайный1 = новый случайный (100); System.out.println (random1.nextint ()); System.out.println (random1.nextfloat ()); System.out.println (random1.nextboolean ()); Случайный случайный 2 = новый случайный (100); System.out.println (random2.nextint ()); System.out.println (random2.nextfloat ()); System.out.println (random2.nextboolean ()); }} 2> Случайные числа в указанном диапазоне
Случайные числа контролируются в определенном диапазоне, используя оператор модуля %
Импорт java.util.*; Class testrandom {public static void main (string [] args) {случайный случайный = new random (); for (int i = 0; i <10; i ++) {System.out.println (math.abs (random.nextint ())); }}}Полученные случайные числа являются положительными и отрицательными. Используйте Math.abs, чтобы сделать диапазон данных полученным в качестве неотрицательных чисел.
3> Получите неповрежденные случайные числа в указанном диапазоне
Импорт java.util.*; Class testrandom {public static void main (string [] args) {int [] intret = new Int [6]; intrd = 0; // хранилище случайные числа int count = 0; // Записать сгенерированные случайные числа int flag = 0; // был ли флаг сгенерирован, в то время как (count <6) {случайный rdm = new Random (System.currentTimeMillis ()); intrd = math.abs (rdm.nextint ()) 2+1; for (int i = 0; i <count; i ++) {if (intret [i] == intrd) {flag = 1; перерыв; } else {flag = 0; }} if (flag == 0) {intret [count] = intrd; count ++; }} for (int t = 0; t <6; t ++) {System.out.println (t+"->"+Intret [t]); }}} Можно ли повторить случайные числа в Java? Можно ли использовать случайные числа, сгенерированные в Java, для генерации первичных ключей базы данных? Имея в виду этот вопрос, мы провели серию тестов.
1. Тест 1: используйте конструктор случайного () без параметров
открытый класс случайный {public static void main (string [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ()); }}} Результаты запуска программы:
-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157
Запустите программу снова:
-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608
Из приведенного выше теста мы видим, что случайные числа, сгенерированные с использованием конструктора random () без параметров, не будут повторяться. Итак, при каких обстоятельствах Java производит дубликаты случайных чисел? Давайте посмотрим на тест ниже.
2. Тест 2: Установите количество семян для случайных
открытый класс randomTest_repeat {public static void main (string [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ()); }}} Независимо от того, сколько раз работает программа, результат всегда:
-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428
Даже если вы тестируете его на разных машинах, результаты испытаний не изменятся!
3. Анализ причина:
(1) Во -первых, откройте Java Doc, мы увидим описание случайного класса:
Примеры этого класса используются для генерации псевдолупиточных потоков, которые используют 48-битное семя, которое можно изменить с использованием линейной конгруэнтной формулы (см. Дональд Кнут «Искусство компьютерного программирования», том 2, раздел 3.2.1).
Если два случайных экземпляра создаются с одним и тем же семенем, в каждом экземпляре производится одна и та же последовательность вызовов методов, и они будут генерировать и возвращать одну и ту же последовательность чисел. Чтобы обеспечить реализацию этой функции, мы указываем конкретный алгоритм для случайного класса. Для полной переносимости кода Java реализации Java должны иметь класс случайным образом использовать все алгоритмы, показанные здесь. Но подклассам случайного класса разрешено использовать другие алгоритмы, если они соответствуют обычным соглашениям всех методов.
Java Doc очень хорошо объяснил случайный класс, и наши тесты подтвердили это.
(2) Если число семян не предоставлено, количество семян случайного экземпляра будет миллисекундами текущего времени. Вы можете получить миллисекунды текущего времени через System.currentTimeMillis (). Откройте исходный код JDK, и мы можем увидеть это очень четко.
public random () {this (System.currentTimeMillis ()); } 4. Заключение:
Благодаря вышеупомянутым тестам и анализу у нас будет более глубокое понимание случайного класса. В то же время, я думаю, что, прочитав документацию Java DOC API, наши возможности программирования Java могут быть значительно улучшены, и «знание правды» может быть достигнуто; Как только мы столкнулись с озадаченными проблемами, мы могли бы также открыть исходный код Java, чтобы мы могли «знать правду».
В Java обычно существует два типа случайных чисел, один из них является случайным () методом в математике, а другой - случайный класс.
1. Math.random ()
Десятичное число 0 <x <1 генерируется.
Пример: как написать и генерировать случайным образом одно из чисел от 0 до 100?
Math.random () возвращает только десятичное значение от 0 до 1. Если вы хотите от 50 до 100, вы сначала увеличитесь на 50 раз, то есть от 0 до 50. Здесь все еще десятичный. Если вы хотите целое число, вы будете разыграть Int, а затем добавить от 50 до 50 до 100.
Окончательный код: (int) (math.random ()*50) + 50
2. Случайный класс
Random random = new random (); // конструктор по умолчанию случайный случайный = new random (1000); // указать номер семян
При выполнении рандомизации количество происхождения случайного алгоритма называется семенами, что выполняет определенное преобразование на основе семян, тем самым генерируя необходимые случайные числа.
Случайные объекты с одинаковым количеством семян, случайные числа, генерируемые одинаковым количеством раз, точно одинаковы. Другими словами, для двух случайных объектов с одним и тем же числом семян случайные числа, сгенерированные в первый раз, точно одинаковы, а случайные числа, сгенерированные во второй раз, точно одинаковы.
2. Общие методы в случайном классе
Методы в случайном классе относительно просты, и функции каждого метода также легко понять. Следует отметить, что случайные числа, генерируемые каждым методом в случайном классе, равномерно распределены, что означает, что вероятность численной генерации в интервале равен. Вот основное введение в эти методы:
A, Public Boolean Nextboolean ()
Функция этого метода состоит в том, чтобы генерировать случайное логическое значение, а вероятность генерации истинных и ложных значений равна, то есть оба составляют 50%.
b, public DoubledDuble ()
Цель этого метода состоит в том, чтобы генерировать случайное двойное значение, значение между [0, 1,0). Здесь кронштейны представляют собой конечные точки, содержащие интервал, а скобки представляют собой конечные точки, которые не включают интервал, то есть случайный десятичный десятичный
c, public int nextint ()
Цель этого метода состоит в том, чтобы генерировать случайное значение int, которое находится между 31 -й мощностью -2 и 31 -й мощностью мощности 2.
Если вам нужно генерировать значение Int для указанного интервала, вам необходимо выполнить определенное математическое преобразование. Для получения подробной информации, пожалуйста, обратитесь к коду в примере использования ниже.
D, public int nextint (int n)
Функция этого метода состоит в том, чтобы генерировать случайное значение int, которое находится в интервале [0, N), то есть случайное значение int между 0 и n, содержащее 0, но не n.
Если вы хотите генерировать значение Int для указанного интервала, вам также необходимо выполнить определенное математическое преобразование. Для получения подробной информации, пожалуйста, обратитесь к коду в примере использования ниже.
E, Публичный пустотный набор (длинное семя)
Цель этого метода - сбросить количество семян в случайном объекте. После установки количества семян случайный объект такой же, как и случайный объект, созданный с новым ключевым словом.
3. Пример использования случайного класса
Используя случайный класс, это обычно для генерации случайных чисел для указанного интервала. Следующее представит, как генерировать случайные числа для соответствующего интервала один за другим. Следующие коды, которые генерируют случайные числа, генерируются с использованием следующего случайного объекта r:
Случайный r = new Random ();
а Генерировать десятичные дскаимы интервала [0,1,0)
double d1 = r.nextdouble ();
Он получается непосредственно с использованием следующего метода.
беременный Генерировать десятичные дскаимы интервала [0,5,0)
double d2 = r.nextdouble () * 5;
Поскольку чисел интервал, сгенерированный следующим, составляет [0, 1,0), расширение интервала в 5 раз - это необходимый интервал.
Точно так же, чтобы генерировать случайный десятичный десятичный язык в интервале [0, D) и D является любого положительного десятичного десятичного, вам нужно только умножить возвращаемое значение следующего метода на D.
в Генерировать десятичное число [n1, n2] интервала [1, 2,5) [1]
Double d3 = r.nextdouble () * 1,5 + 1; 【то есть, r.nextdouble () * (n2-n1) + n1】
Чтобы генерировать случайный десятичный десятичный интервал [1, 2,5), вам нужно только сначала генерировать случайное количество интервала [0, 1,5), а затем добавить 1 в сгенерированный интервал случайного числа.
Точно так же, чтобы генерировать любое случайное число в диапазоне десятичного интервала [D1, D2), которое не начинается с 0 (где D1 не равен 0), вам нужно только сначала генерировать случайное число в интервале [0, D2-D1), а затем добавить сгенерированный интервал случайного числа в D1.
дюймовый Генерировать любое целое число
int n1 = r.nextint ();
Просто используйте метод Nextint напрямую.
эн. Генерировать целые числа в интервале [0,10)
int n2 = r.nextint (10); n2 = math.abs (r.nextint () % 10);
Вышеуказанные две строки кода могут генерировать целые числа в интервале [0,10).
Первая реализация напрямую реализуется с использованием метода NextInt (int N) в случайном классе.
Во второй реализации метод First Call NextInt () для создания произвольного числа Int. Интервал, сгенерированный численной суммой числа 10, составляет (-10,10), поскольку в соответствии с математической спецификацией абсолютное значение оставшегося меньше, чем делитель, а затем рассчитывается абсолютное значение интервала, и полученный интервал составляет [0,10).
Точно так же, чтобы генерировать случайные целые числа в любом интервале [0, n) вы можете использовать следующий код:
int n2 = r.nextint (n); n2 = math.abs (r.nextint () % n);
фон Генерировать целые числа в интервале [0,10]
int n3 = r.nextint (11); n3 = math.abs (r.nextint () % 11);
По сравнению с целочисленным интервалом интервал [0,10] и интервал [0,11) эквивалентны, поэтому генерируется целое число [0,11) интервала.
глин Генерировать целые числа в интервале [-3,15)
int n4 = r.nextint (18) - 3; // 【то есть r.nextint () * (n2 -n1)+n1】 n1 - отрицательное число n4 = math.abs (r.nextint () % 18) - 3;
Чтобы сгенерировать случайные целые числа, которые не начинаются с 0, вы можете ссылаться на приведенное выше описание принципа реализации десятичного интервала, который не начинается с 0.
Выше всего содержание этой статьи. Я надеюсь, что это будет полезно для каждого обучения, и я надеюсь, что все будут поддерживать Wulin.com больше.