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

<p>как создать случайное значение <code>int</code> в определенном диапазоне?</p><p>я пробовал следующее, но они не работают:</p><p><strong> попытка 1: </strong></p><pre><code>randomnum = minimum + (int)(math.random() * maximum); // bug: `randomnum` can be bigger than `maximum`. </code></pre><p><strong> попытка 2: </strong></p><pre><code>random rn = new random(); int n = maximum - minimum + 1; int i = rn.nextint() % n; randomnum = minimum + i; // bug: `randomnum` can be smaller than `minimum`. </code></pre>

<p>в <strong>java 1.7 или более поздних версиях</strong> стандартный способ сделать это заключается в следующем:</p><pre><code>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); </code></pre><p>смотрите <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/threadlocalrandom.html#nextint(int,int)">соответствующий javadoc</a> . преимущество этого подхода состоит в том, что нет необходимости явно инициализировать <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/random.html">java.util.random</a> instance, который может стать источником путаницы и ошибок, если используется не по назначению.</p><p>однако, наоборот, нет способа явно установить начальное число, поэтому может быть трудно воспроизвести результаты в ситуациях, когда это полезно, таких как тестирование или сохранение игровых состояний или тому подобное. в этих ситуациях может использоваться методика до java 1.7, показанная ниже.</p><p><strong>до java 1.7</strong> стандартный способ сделать это был следующим:</p><pre><code>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; } </code></pre><p>смотрите <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/random.html#nextint(int)">соответствующий javadoc</a> . на практике класс <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/random.html">java.util.random</a> часто предпочтительнее, чем <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/math.html#random()">java.lang.math.random ()</a> .</p><p>в частности, нет необходимости заново изобретать колесо генерации случайных целых чисел, когда в стандартной библиотеке имеется простой api для выполнения задачи.</p>

<p>обратите внимание, что этот подход является более предвзятым и менее эффективным, чем подход <code>nextint</code>, <a href="https://stackoverflow.com/a/738651/360211">https://stackoverflow.com/a/738651/360211</a> </p><p>один стандартный шаблон для достижения этой цели:</p><pre><code>min + (int)(math.random() * ((max - min) + 1)) </code></pre><p>функция библиотеки <a href="http://en.wikipedia.org/wiki/java\_%28programming\_language%29">java</a> math math.random () генерирует двойное значение в диапазоне <code>[0,1)</code>. обратите внимание, что этот диапазон не включает 1.</p><p>чтобы сначала получить определенный диапазон значений, необходимо умножить его на величину диапазона значений, который вы хотите охватить. </p><pre><code>math.random() * ( max - min ) </code></pre><p>это возвращает значение в диапазоне <code>[0,max-min)</code>, где «max-min» не включен.</p><p>например, если вы хотите <code>[5,10)</code>, вам нужно указать пять целочисленных значений, чтобы вы использовали</p><pre><code>math.random() * 5 </code></pre><p>это вернет значение в диапазоне <code>[0,5)</code>, где 5 не включено.</p><p>теперь вам нужно сместить этот диапазон до диапазона, на который вы нацеливаетесь. вы делаете это, добавляя значение min.</p><pre><code>min + (math.random() * (max - min)) </code></pre><p>теперь вы получите значение в диапазоне <code>[min,max)</code>. следуя нашему примеру, это означает <code>[5,10)</code>:</p><pre><code>5 + (math.random() * (10 - 5)) </code></pre><p>но это все еще не включает <code>max</code>, и вы получаете двойное значение. чтобы получить включенное значение <code>max</code>, вам нужно добавить 1 к параметру диапазона <code>(max - min)</code> и затем усечь десятичную часть, приведя к int. это достигается с помощью:</p><pre><code>min + (int)(math.random() * ((max - min) + 1)) </code></pre><p>и там у вас есть это. случайное целочисленное значение в диапазоне <code>[min,max]</code> или в примере <code>[5,10]</code>:</p><pre><code>5 + (int)(math.random() * ((10 - 5) + 1)) </code></pre>

<p>использование:</p><pre><code>random ran = new random(); int x = ran.nextint(6) + 5; </code></pre><p>целое число <code>x</code> теперь является случайным числом, которое имеет возможный результат <code>5-10</code>.</p>

<p>использование:</p><pre><code>minimum + rn.nextint(maxvalue - minvalue + 1) </code></pre>

<p>с <a href="/questions/tagged/java-8">java-8</a> они представили метод <a href="http://docs.oracle.com/javase/8/docs/api/java/util/random.html#ints-int-int-"><code>ints(int randomnumberorigin, int randomnumberbound)</code></a> в классе <a href="http://docs.oracle.com/javase/8/docs/api/java/util/random.html"><code>random</code></a> .</p><p>например, если вы хотите сгенерировать пять случайных целых (или одно) в диапазоне [0, 10], просто выполните:</p><pre><code>random r = new random(); int[] fiverandomnumbers = r.ints(5, 0, 11).toarray(); int randomnumber = r.ints(1, 0, 11).findfirst().getasint(); </code></pre><p>первый параметр указывает только размер сгенерированной <code>intstream</code> (который является перегруженным методом того, который создает неограниченную <code>intstream</code>).</p><p>если вам нужно сделать несколько отдельных вызовов, вы можете создать бесконечный примитивный итератор из потока:</p><pre><code>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(); } } </code></pre><p>вы также можете сделать это для значений <code>double</code> и <code>long</code>.</p><p>надеюсь, поможет! :)</p>

<p>вы можете отредактировать свой второй пример кода:</p><pre><code>random rn = new random(); int range = maximum - minimum + 1; int randomnum = rn.nextint(range) + minimum; </code></pre>

<p>достаточно небольшой модификации вашего первого решения.</p><pre><code>random rand = new random(); randomnum = minimum + rand.nextint((maximum - minimum) + 1); </code></pre><hr><p>смотрите больше здесь для реализации <a href="https://insight.io/github.com/lambdalab-mirror/jdk8u-jdk/blob/master/src/share/classes/java/util/random.java?line=77"><code>random</code></a> </p>

<p>threadlocalrandom эквивалент класса java.util.random для многопоточной среды. генерация случайного числа осуществляется локально в каждом из потоков. таким образом, мы имеем лучшую производительность за счет уменьшения конфликтов. </p><pre><code>int rand = threadlocalrandom.current().nextint(x,y); </code></pre><p>x, y - интервалы, например (1,10)</p>

<p>класс <code>math.random</code> в <a href="http://en.wikipedia.org/wiki/java\_%28programming\_language%29">java</a> основан на 0. итак, если вы напишите что-то вроде этого: </p><pre><code>random rand = new random(); int x = rand.nextint(10); </code></pre><p><code>x</code> будет между <code>0-9</code> включительно.</p><p>таким образом, учитывая следующий массив элементов <code>25</code>, код для генерации случайного числа между <code>0</code> (основание массива) и <code>array.length</code> будет:</p><pre><code>string[] i = new string[25]; random rand = new random(); int index = 0; index = rand.nextint( i.length ); </code></pre><p>так как <code>i.length</code> вернет <code>25</code>, <code>nextint( i.length )</code> вернет число в диапазоне от <code>0-24</code>. другой вариант идет с <code>math.random</code>, который работает таким же образом.</p><pre><code>index = (int) math.floor(math.random() * i.length); </code></pre><p>для лучшего понимания просмотрите сообщение на форуме <em> <a href="http://web.archive.org/web/20070308142422/http://www.kirupa.com/forum/showthread.php?s=&postid=81565">случайные интервалы (archive.org)</a> </em>.</p>

<p>прости меня за привередливость, но решение, предложенное большинством, то есть <code>min + rng.nextint(max - min + 1))</code>, кажется опасным из-за того, что:</p><ul> <li><code>rng.nextint(n)</code> не может достичь <code>integer.max\_value</code>.</li> <li><code>(max - min)</code> может вызвать переполнение, если <code>min</code> отрицателен.</li> </ul><p>надежное решение вернет правильные результаты для любого <code>min <= max</code> в пределах [<code>integer.min\_value</code>, <code>integer.max\_value</code>]. рассмотрим следующую наивную реализацию:</p><pre><code>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; } </code></pre><p>хотя это неэффективно, обратите внимание, что вероятность успеха в цикле <code>while</code> всегда будет 50% или выше.</p>

<p>интересно, подойдет ли какой-либо из методов генерации случайных чисел, предоставляемых библиотекой <a href="http://commons.apache.org/proper/commons-math/">apache commons math</a> . </p><p>например: <a href="http://commons.apache.org/proper/commons-math/javadocs/api-3.6.1/org/apache/commons/math3/random/randomdatagenerator.html#nextint(int,%20int)"><code>randomdatagenerator.nextint</code></a> или <a href="http://commons.apache.org/proper/commons-math/javadocs/api-3.6.1/org/apache/commons/math3/random/randomdatagenerator.html#nextlong(long,%20long)"><code>randomdatagenerator.nextlong</code></a> </p>

<p>давайте возьмем пример.</p><p>предположим, я хочу сгенерировать число между<strong> 5-10 </strong>:</p><pre><code>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); </code></pre><p><em>дайте нам понять это</em> ...</p><blockquote> <blockquote> <p>инициализируйте max с самым высоким значением и min с самым низким значением. </p> <p>теперь нам нужно определить, сколько возможных значений можно получить. для этого примера это будет:</p> <blockquote> <p><strong> 5, 6, 7, 8, 9, 10 </strong></p> </blockquote> <p>таким образом, счет этого будет макс - мин + 1. </p> <blockquote> <p>то есть 10 - 5 + 1 = 6</p> </blockquote> <p>случайное число будет генерировать число между<strong> 0-5 </strong>. </p> <blockquote> <p>то есть 0, 1, 2, 3, 4, 5</p> </blockquote> <p>добавление значения <em>min</em> к случайному числу приведет к:</p> <blockquote> <p>5, 6, 7, 8, 9, 10 </p> </blockquote> <p>отсюда получаем желаемый диапазон. </p> </blockquote> </blockquote>

<pre><code> rand.nextint((max+1) - min) + min; </code></pre>

<p>сгенерируйте случайное число для разницы min и max, используя метод <a href="http://docs.oracle.com/javase/6/docs/api/java/util/random.html#nextint(int)">nextint (n)</a> , а затем добавьте минимальное число к результату:</p><pre><code>random rn = new random(); int result = rn.nextint(max - min + 1) + min; system.out.println(result); </code></pre>

<blockquote> <p>начиная с java 7, вы больше не должны использовать <code>random</code>. для большинства случаев генератор случайных чисел по выбору теперь <a href="https://stackoverflow.com/questions/363681/how-do-i-generate-random-integers-within-a-specific-range-in-java#answer-363692"><code>threadlocalrandom</code></a> .<br/><br/>для пулов вил и соединения параллельно потоки, используйте <a href="https://docs.oracle.com/javase/8/docs/api/java/util/splittablerandom.html"><code>splittablerandom</code></a> .</p> </blockquote><p><em>джошуа блох. эффективная java. третье издание.</em></p><h2>начиная с java 8</h2><p>для пулов объединения вилок и параллельных потоков используйте <code>splittablerandom</code>, который обычно быстрее, обладает лучшими свойствами статистической независимости и однородности по сравнению с <code>random</code>.</p><p>для генерации случайного <code>int</code> в диапазоне <code>[0, 1\_000]:</code></p><pre><code>int n = new splittablerandom().nextint(0, 1\_001); </code></pre><p>для генерации случайного массива значений <code>int[100]</code> в диапазоне <code>[0, 1\_000]:</code></p><pre><code>int[] a = new splittablerandom().ints(100, 0, 1\_001).parallel().toarray(); </code></pre><p>чтобы вернуть поток случайных значений:</p><pre><code>intstream stream = new splittablerandom().ints(100, 0, 1\_001); </code></pre>

<p>в случае броска кубика это будет случайное число от 1 до 6 (не от 0 до 6), поэтому: </p><pre><code>face = 1 + randomnumbers.nextint(6); </code></pre>

<p>вот полезный класс для генерации случайных <code>ints</code> в диапазоне с любой комбинацией включающих/исключающих границ:</p><pre><code>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; } } </code></pre>

<pre><code>int random = minimum + double.valueof(math.random()*(maximum-minimum )).intvalue(); </code></pre><p>или взгляните на randomutils из <a href="http://commons.apache.org/lang">apache commons</a> .</p>

<p>чтобы сгенерировать случайное число «между двумя числами», используйте следующий код:</p><pre><code>random r = new random(); int lowerbound = 1; int upperbound = 11; int result = r.nextint(upperbound-lowerbound) + lowerbound; </code></pre><p>это дает вам случайное число от 1 (включительно) до 11 (исключение), поэтому инициализируйте значение upperbound, добавив 1. например, если вы хотите сгенерировать случайное число от 1 до 10, инициализируйте число upperbound с 11 вместо 10.</p>

<p>эти методы могут быть удобны в использовании:</p><p>этот метод вернет случайное число<strong> <em>между</em> </strong>предоставленным минимальным и максимальным значением:</p><pre><code>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; } } </code></pre><p>и этот метод возвратит случайное число<strong> <em>из</em> </strong>предоставленного минимального и максимального значения (поэтому сгенерированное число также может быть минимальным или максимальным числом):</p><pre><code>public static int getrandomnumberfrom(int min, int max) { random foo = new random(); int randomnumber = foo.nextint((max + 1) - min) + min; return randomnumber; } </code></pre>

<p>просто используйте <a href="http://docs.oracle.com/javase/6/docs/api/java/util/random.html">случайный</a> класс: </p><pre><code>random ran = new random(); // assumes max and min are non-negative. int randomint = min + ran.nextint(max - min + 1); </code></pre>

<p>я нашел этот пример <a href="http://www.javapractices.com/topic/topicaction.do?id=62">генерация случайных чисел</a> : </p><hr><p>в этом примере генерируются случайные целые числа в определенном диапазоне. </p><pre><code>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); } } </code></pre><p>пример запуска этого класса:<br/></p><pre><code>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. </code></pre>

<p>вы можете достичь этого кратко в java 8:</p><pre><code>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); </code></pre>

<p>когда вам нужно много случайных чисел, я не рекомендую случайный класс в api. у него слишком маленький период. попробуйте <a href="http://en.wikipedia.org/wiki/mersenne\_twister">mersenne twister</a> вместо. существует <a href="http://cs.gmu.edu/~sean/research/">реализация java</a> .</p>

<pre><code>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); } </code></pre>

<p>другой вариант - просто использовать <a href="http://en.wikipedia.org/wiki/apache\_commons">apache commons</a> : </p><pre><code>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); // ... } </code></pre>

<p>вот простой пример, который показывает, как генерировать случайное число из закрытого диапазона <code>[min, max]</code>, в то время как <code>min <= max is true</code></p><p>вы можете использовать его как поле в классе отверстия, также имея все методы <code>random.class</code> в одном месте</p><p><strong> пример результатов: </strong></p><pre><code>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 </code></pre><p><strong> источники: </strong></p><pre><code>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; } } </code></pre>

<pre><code>private static random random = new random(); public static int getrandomint(int min, int max){ return random.nextint(max - min + 1) + min; } </code></pre><p>or</p><pre><code>public static int getrandomint(random random, int min, int max) { return random.nextint(max - min + 1) + min; } </code></pre>

<p>если вы хотите попробовать ответ с большинством голосов выше, вы можете просто использовать этот код:</p><pre><code>public class randomizer { public static int generate(int min,int max) { return min + (int)(math.random() * ((max - min) + 1)); } public static void main(string[] args) { system.out.println(randomizer.generate(0,10)); } } </code></pre><p>это просто чисто и просто.</p>

<p>лучше использовать <a href="http://docs.oracle.com/javase/7/docs/api/java/security/securerandom.html">securerandom</a> , чем просто random.</p><pre><code>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; } </code></pre>

<pre><code>rand.nextint((max+1) - min) + min; </code></pre><p>это работает нормально. </p>

<p>я использую это:</p><pre><code> /** * @param min - the minimum. * @param max - the maximum. * @return a random double between these numbers (inclusive the minimum and maximum). */ public static double getrandom(double min, double max) { return (math.random() * (max+1-min)) + min; } </code></pre><p>вы можете привести его к integer, если хотите.</p>

<pre><code>import java.util.random; public class randomutil { // declare as class variable so that it is not re-seeded every call private static random random = new random(); /** * returns a psuedo-random number between min and max (both inclusive) * @param min minimim value * @param max maximim value. must be greater than min. * @return integer between min and max (both inclusive) * @see java.util.random#nextint(int) */ public static int nextint(int min, int max) { // nextint is normally exclusive of the top value, // so add 1 to make it inclusive return random.nextint((max - min) + 1) + min; } } </code></pre>

<p>вы можете сделать что-то вроде этого:</p><pre><code>import java.awt.*; import java.io.*; import java.util.*; import java.math.*; public class test { public static void main(string[] args) { int first, second; scanner myscanner = new scanner(system.in); system.out.println("enter first integer: "); int numone; numone = myscanner.nextint(); system.out.println("you have keyed in " + numone); system.out.println("enter second integer: "); int numtwo; numtwo = myscanner.nextint(); system.out.println("you have keyed in " + numtwo); random generator = new random(); int num = (int)(math.random()*numtwo); system.out.println("random number: " + ((num>numone)?num:numone+num)); } } </code></pre>

<p>вы можете использовать этот фрагмент кода, который решит вашу проблему: </p><pre><code>random r = new random(); int myrandomnumber = 0; myrandomnumber = r.nextint(maxvalue-minvalue+1)+minvalue; </code></pre><p>используйте myrandomnumber (который даст вам номер в диапазоне).</p>

<p><strong> другой подход с использованием java 8 intstream и collections.shuffle </strong></p><pre><code>import java.util.stream.intstream; import java.util.arraylist; import java.util.collections; public class main { public static void main(string[] args) { intstream range = intstream.rangeclosed(5,10); arraylist<integer> ls = new arraylist<integer>(); //populate the arraylist range.foreach(i -> ls.add(new integer(i)) ); //perform a random shuffle using the collections fisher-yates shuffle collections.shuffle(ls); system.out.println(ls); } } </code></pre><p><strong> эквивалент в scala </strong></p><pre><code>import scala.util.random object randomrange extends app{ val x = random.shuffle(5 to 10) println(x) } </code></pre>

<p>я просто скажу, что не так с решениями, предоставленными вопросом, и почему ошибки. </p><p>решение 1:</p><pre><code>randomnum = minimum + (int)(math.random()*maximum); </code></pre><p>проблема: для randomnum присваиваются значения чисел больше максимального.</p><p>объяснение: предположим, что наш минимум равен 5, а ваш максимум равен 10. любое значение из <code>math.random()</code> больше 0,6 заставит выражение оценить значение 6 или больше, а добавление 5 сделает его больше 10 (ваш максимум). проблема в том, что вы умножаете случайное число на максимум (который генерирует число, почти равное максимуму), а затем добавляете минимум. если минимум не равен 1, это не правильно. вы должны переключиться на, как указано в других ответах</p><pre><code>randomnum = minimum + (int)(math.random()*(maximum-minimum+1)) </code></pre><p>+1 потому что <code>math.random()</code> никогда не вернет 1.0.</p><p>решение 2:</p><pre><code>random rn = new random(); int n = maximum - minimum + 1; int i = rn.nextint() % n; randomnum = minimum + i; </code></pre><p>ваша проблема здесь в том, что «%» может вернуть отрицательное число, если первый член меньше 0. так как <code>rn.nextint()</code> возвращает отрицательные значения с вероятностью ~ 50%, вы также не получите ожидаемый результат.</p><p>это было, однако, почти идеально. вам просто нужно было посмотреть немного дальше вниз по javadoc, <a href="http://docs.oracle.com/javase/6/docs/api/java/util/random.html#nextint%28int%29">nextint (int n)</a> . с этим методом доступны, делая</p><pre><code>random rn = new random(); int n = maximum - minimum + 1; int i = rn.nextint(n); randomnum = minimum + i; </code></pre><p>также вернул бы желаемый результат.</p>

<pre><code>random random = new random(); int max = 10; int min = 3; int randomnum = random.nextint(max) % (max - min + 1) + min; </code></pre>

<p>вы могли бы использовать </p><pre><code>randomstringutils.randomnumeric(int count) </code></pre><p>метод также из apache commons. </p>

<pre><code>import java.util.random; public class randomssntest { public static void main(string args[]) { generatedummyssnnumber(); } //831-33-6049 public static void generatedummyssnnumber() { random random = new random(); int id1 = random.nextint(1000);//3 int id2 = random.nextint(100);//2 int id3 = random.nextint(10000);//4 system.out.print((id1+"-"+id2+"-"+id3)); } } </code></pre><p>вы также можете использовать </p><pre><code>import java.util.concurrent.threadlocalrandom; random random = threadlocalrandom.current(); </code></pre><p>однако этот класс не очень хорошо работает в многопоточной среде.</p>

<p>внесение следующих изменений в <strong>попытка 1</strong> должно сделать работу - </p><pre><code>randomnum = minimum + (int)(math.random() * (maximum - minimum) ); </code></pre><p>проверьте <a href="https://ideone.com/20nxu9">это</a> для рабочего кода.</p>

<p>я думаю, чтобы линейно нормализовать сгенерированные случайные числа в желаемом диапазоне, используя следующее. пусть <code>x</code> будет случайным числом, пусть <code>a</code> и <code>b</code> будут минимальным и максимальным диапазоном желаемого нормализованного числа.</p><p>ниже приведен лишь очень простой фрагмент кода для проверки диапазона, получаемого линейным отображением.</p><pre><code>public static void main(string[] args) { int a = 100; int b = 1000; int lowest = b; int highest = a; int count = 100000; random random = new random(); for (int i = 0; i < count; i++) { int nextnumber = (int) ((math.abs(random.nextdouble()) * (b - a))) + a; if (nextnumber < a || nextnumber > b) { system.err.println("number not in range :" + nextnumber); } else { system.out.println(nextnumber); } if (nextnumber < lowest) { lowest = nextnumber; } if (nextnumber > highest) { highest = nextnumber; } } system.out.println("produced " + count + " numbers from " + lowest + " to " + highest); } </code></pre>

<p>я просто генерирую случайное число с помощью math.random () и умножаю его на большое число, скажем, 10000. итак, я получаю число от 0 до 10000 и называю это число <code>i</code>. теперь, если мне нужны числа между (x, y), сделайте следующее:</p><pre><code>i = x + (i % (y - x)); </code></pre><p>итак, все <code>i</code> являются числами от x до y.</p><p>чтобы убрать смещение, как указано в комментариях, вместо умножения его на 10000 (или большого числа), умножьте его на (y-x).</p>

<p>я думаю, что этот код будет работать для него. пожалуйста, попробуйте это: </p><pre><code>import java.util.random; public final class randomnumber { public static final void main(string... aargs) { log("generating 10 random integers in range 1..10."); int start = 1; int end = 10; random randomgenerator = new random(); for (int idx=1; idx<=10; ++idx) { // int randomint=randomgenerator.nextint(100); // log("generated : " + randomint); showrandominteger(start,end,randomgenerator); } log("done"); } private static void log(string amessage) { system.out.println(amessage); } private static void showrandominteger(int astart, int aend, random arandom) { if (astart > aend) { throw new illegalargumentexception("start cannot exceed end."); } long range = (long)aend - (long)astart + 1; long fraction = (long) (range * arandom.nextdouble()); int randomnumber = (int) (fraction + astart); log("generated" + randomnumber); } } </code></pre>

<p>если вы уже используете <code>commons lang api 2.x</code> или последнюю версию, тогда существует один класс для генерации случайных чисел <code>randomutils</code>.</p><pre><code>public static int nextint(int n) </code></pre><p>возвращает псевдослучайное, равномерно распределенное значение типа int между 0 (включительно) и указанным значением (исключая) из последовательности math.random ().</p><p>параметры: <strong>n</strong> - указанное эксклюзивное максимальное значение</p><pre><code>int random = randomutils.nextint(1000000); </code></pre><p>примечание: в <a href="https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/math/randomutils.html#nextint(java.util.random)">randomutils</a> есть много методов для генерации случайных чисел </p>

<p>приведенный ниже код генерирует случайное число от 100 000 до 900 000. этот код будет генерировать шестизначные значения. я использую этот код для генерации шестизначного <a href="https://en.wikipedia.org/wiki/one-time\_password">otp</a> .</p><p>используйте <code>import java.util.random</code>, чтобы использовать этот случайный метод.</p><pre><code>import java.util.random; // six digits random number generation for otp random rnd = new random(); long longregisterotp = 100000 + rnd.nextint(900000); system.out.println(longregisterotp); </code></pre>

<p>вы можете использовать класс random для генерации случайного числа, а затем использовать .nextint (maxnumber) для генерации случайного числа. maxnumber - это число, которое вы хотите максимум при генерации случайного числа. пожалуйста, помните, что класс random дает вам числа от 0 до maxnumber-1. </p><pre><code>random r = new random(); int i = r.nextint(); </code></pre><p>другой способ сделать это - использовать класс math.random (), который требуется от многих классов в школах, потому что он более эффективен и вам не нужно объявлять новый объект random. чтобы получить случайное число с помощью math.random (), введите:</p><pre><code>math.random() * (max - min) + min; </code></pre>

<p>будет сгенерирован список <strong>случайных чисел</strong> с <strong>range (min - max)</strong> с <strong>no duplicate</strong>.</p><pre><code>generaterandomlistnoduplicate(1000, 8000, 500); </code></pre><p>добавьте этот метод.</p><pre><code>private void generaterandomlistnoduplicate(int min, int max, int totalnorequired) { random rng = new random(); set<integer> generatedlist = new linkedhashset<>(); while (generatedlist.size() < totalnorequired) { integer radnomint = rng.nextint(max - min + 1) + min; generatedlist.add(radnomint); } } </code></pre><p>надеюсь, что это поможет вам.</p>

<p>я создал метод, чтобы получить уникальное целое число в заданном диапазоне.</p><pre><code>/* * minnum is the minimum possible random number * maxnum is the maximum possible random number * numbersneeded is the quantity of random number required * the give method provides you with unique random number between min & max range */ public static set<integer> getuniquerandomnumbers( int minnum , int maxnum ,int numbersneeded ){ if(minnum >= maxnum) throw new illegalargumentexception("maxnum must be greater than minnum"); if(! (numbersneeded > (maxnum - minnum + 1) )) throw new illegalargumentexception("numberneeded must be greater then difference b/w (max- min +1)"); random rng = new random(); // ideally just create one instance globally // note: use linkedhashset to maintain insertion order set<integer> generated = new linkedhashset<integer>(); while (generated.size() < numbersneeded) { integer next = rng.nextint((maxnum - minnum) + 1) + minnum; // as we're adding to a set, this will automatically do a containment check generated.add(next); } return generated; } </code></pre>

<p>допустим, вы хотите диапазон от 0 до 9, 0 - это минимум, а 9 - максимум. приведенная ниже функция будет печатать что угодно в диапазоне от 0 до 9. она одинакова для всех диапазонов.</p><pre><code>public static void main(string[] args) { int b = randomnumberrange(0, 9); int d = randomnumberrange (100, 200); system.out.println("value of b is " + b); system.out.println("value of d is " + d); } public static int randomnumberrange(int min, int max) { int n = (max + 1 - min) + min; return (int) (math.random() * n); } </code></pre>

<p>один из моих друзей задал мне этот же вопрос сегодня в университете (его требованием было сгенерировать случайное число между 1 и -1). итак, я написал это, и пока все отлично работает с моим тестированием. в идеале существует множество способов генерирования случайных чисел с заданным диапазоном. попробуй это: </p><p>функция:</p><pre><code>private static float getrandomnumberbetween(float numberone, float numbertwo) throws exception{ if (numberone == numbertwo){ throw new exception("both the numbers can not be equal"); } float rand = (float) math.random(); float highrange = math.max(numberone, numbertwo); float lowrange = math.min(numberone, numbertwo); float lowrand = (float) math.floor(rand-1); float highrand = (float) math.ceil(rand+1); float genrand = (highrange-lowrange)*((rand-lowrand)/(highrand-lowrand))+lowrange; return genrand; } </code></pre><p>выполните так:</p><pre><code>system.out.println( getrandomnumberbetween(1,-1)); </code></pre>

<p>ниже приведен еще один пример использования random и foreach.</p><pre><code>int firstnum = 20;//inclusive int lastnum = 50;//exclusive int streamsize = 10; random num = new random().ints(10, 20, 50).foreach(system.out::println); </code></pre>

<p>есть библиотека по адресу <a href="https://sourceforge.net/projects/stochunit/">https://sourceforge.net/projects/stochunit/</a> для обработки выбора диапазонов.</p><pre><code>stochintegerselector randomintegerselector = new stochintegerselector(); randomintegerselector.setmin(-1); randomintegerselector.setmax(1); integer selectinteger = randomintegerselector.selectinteger(); </code></pre><p>имеет edge-включение/исключение.</p>

<p>простой способ генерировать n случайных чисел между a и b например, a = 90, b = 100, n = 20</p><pre><code>random r = new random(); for(int i =0; i<20; i++){ system.out.println(r.ints(90, 100).iterator().nextint()); } </code></pre><p><code>r.ints()</code> возвращает <code>intstream</code> и имеет несколько полезных методов, посмотрите на его <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/intstream.html">api</a> .</p>

<p>попробуйте использовать класс <code>org.apache.commons.lang.randomstringutils</code>. да, иногда он дает повторяющееся число рядом, но это даст значение от 5 до 15:</p><pre><code> while (true) { int abc = integer.valueof(randomstringutils.randomnumeric(1)); int cd = integer.valueof(randomstringutils.randomnumeric(2)); if ((cd-abc) >= 5 && (cd-abc) <= 15) { system.out.println(cd-abc); break; } } </code></pre>

<p>случайное число из диапазона [min..max] включительно:</p><pre><code>int randomfrommintomaxinclusive = threadlocalrandom.current() .nextint(min, max + 1); </code></pre>

<p>используйте java.util для random для общего пользования.</p><p>вы можете определить свой минимальный и максимальный диапазон, чтобы получить эти результаты.</p><pre><code>random rand=new random(); rand.nextint((max+1) - min) + min; </code></pre>

<p>большинство из вышеперечисленных предложений не учитывают «переполнение», например: min = integer.min\_value, max = 100. один из правильных подходов, которые у меня есть, заключается в следующем:</p><pre><code>final long mod = max- min + 1l; final int next = (int) (math.abs(rand.nextlong() % mod) + min); </code></pre>

<p>это простой способ сделать это.</p><pre><code>import java.util.random; class example{ public static void main(string args[]){ /*-to test- for(int i = 1 ;i<20 ; i++){ system.out.print(randomnumber()+","); } */ int randomnumber = randomnumber(); } public static int randomnumber(){ random rand = new random(); int randomnum = rand.nextint(6) + 5; return randomnum; } } </code></pre><p>там 5 является отправной точкой случайных чисел. 6 - это диапазон, включающий номер 5.</p>

<pre><code>public static void main(string[] args) { random ran = new random(); int min, max; scanner sc = new scanner(system.in); system.out.println("enter min range:"); min = sc.nextint(); system.out.println("enter max range:"); max = sc.nextint(); int num = ran.nextint(min); int num1 = ran.nextint(max); system.out.println("random number between given range is " + num1); } </code></pre>

<p>используйте <code>math.random()</code> и задайте требования в операторе if. самый простой, самый простой и быстрый подход </p>

<p>используя java 8 streams,</p><ul> <li>передайте initialcapacity - сколько чисел</li> <li>передайте randombound - от x до randombound</li> <li>передайте true/false для отсортированных или нет</li> <li>передать новый объект random ()</li> </ul><p></p><pre><code>public static list<integer> generatenumbers(int initialcapacity, int randombound, boolean sorted, random random) { list<integer> numbers = random.ints(initialcapacity, 1, randombound).boxed().collect(collectors.tolist()); if (sorted) numbers.sort(null); return numbers; } </code></pre><p>в этом примере он генерирует числа из 1-randombound.</p>

<p>ниже приведен пример класса, который показывает, как генерировать случайные целые числа в пределах определенного диапазона. присвойте любое значение, которое вы хотите, в качестве максимального значения переменной 'max', и присвойте любое значение, которое вы хотите, в качестве минимального значения переменной 'min'.</p><pre><code>public class randomtestclass { public static void main(string[] args) { random r = new random(); int max = 10; int min = 5; int x; x = r.nextint(max) + min; system.out.println(x); } } </code></pre>

<p>следующий код может быть использован:</p><pre><code>threadlocalrandom.current().nextint(rangestart, rangeendexclusive) </code></pre>