Как сгенерировать случайное значение int
в определенном диапазоне?
Я пробовал следующие варианты, но они не работают:
Попытка 1:
randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.
Попытка 2:
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.
В Java 1.7 или более поздней версии стандартный способ сделать это следующий:
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);
См. соответствующий JavaDoc. Преимуществом этого подхода является отсутствие необходимости явной инициализации экземпляра java.util.Random, который может стать источником путаницы и ошибок при неправильном использовании.
Однако, наоборот, нет способа явно установить семя, поэтому может быть трудно воспроизвести результаты в ситуациях, когда это полезно, например, при тестировании или сохранении состояний игры и т.п. В таких ситуациях можно использовать технику, существовавшую до версии Java 1.7, показанную ниже.
До версии Java 1.7 стандартный способ сделать это был следующим:
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;
}
См. соответствующий JavaDoc. На практике класс java.util.Random часто предпочтительнее java.lang.Math.random().
В частности, нет необходимости заново изобретать колесо генерации случайных целых чисел, когда есть простой API в стандартной библиотеке для выполнения этой задачи.
Обратите внимание, что этот подход является более предвзятым и менее эффективны, чем nextInt подхода, https://stackoverflow.com/a/738651/360211
Один стандартный шаблон для достижения этих целей являются:
Min + (int)(Math.random() * ((Max - Min) + 1))
В Ява математические функции библиотеки по математике.случайный() генерирует значение типа double в диапазоне [0,1)
. Обратите внимание этот диапазон не включает в себя 1.
Для того чтобы получить определенный диапазон значений, во-первых, нужно умножить на величину диапазона значений, которые вы хотите покрыты.
Math.random() * ( Max - Min )
Это возвращает значение в диапазоне `[0,макс-мин), где 'макс-мин' не входит.
Например, если вы хотите[5,10), необходимо, чтобы покрыть пять целочисленных значений, так что вы использовать
Math.random() * 5
Это будет возвращать значение в диапазоне `[0,5), где 5 не входит.
Теперь нужно сдвинуть этот диапазон до диапазона, который вы ориентируетесь. Вы можете сделать это путем добавления минимальное значение.
Min + (Math.random() * (Max - Min))
Теперь вы получите значения в диапазон[мин,макс). Следуя нашему примеру, это означает, что
[5,10)`:
5 + (Math.random() * (10 - 5))
Но, это еще не'т включать "Макс", и вы получаете двойное значение. Для того, чтобы получить значение Max
в комплекте, вам необходимо добавить 1 параметр диапазон(макс - мин) и затем усечение дробной части на кастинг к int. Это достигается через:
Min + (int)(Math.random() * ((Max - Min) + 1))
И там Вы имеете его. Случайное целочисленное значение в диапазоне [мин,макс]
или например [5,10]
:
5 + (int)(Math.random() * ((10 - 5) + 1))
Использование:
Random ran = new Random();
int x = ran.nextInt(6) + 5;
Целое число X
- это теперь случайных чисел, который имеет возможный исход 5-10
.
Используйте:
minimum + rn.nextInt(maxValue - minvalue + 1)
С [тегов:на Java 8] они ввели метод ИНЦ(инт randomNumberOrigin, randomNumberBound инт)
в случайных
класс.
Например, если вы хотите создать пять случайных чисел (или один) в диапазоне [0, 10], Просто сделай:
Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
Первый параметр указывает только размер IntStream
автоматически (что есть перегруженный метод, который производит неограниченное IntStream
).
Если вам нужно сделать несколько отдельных вызовов, вы можете создавать бесконечное примитивное итератор из потока:
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();
}
}
Вы также можете сделать это для двойной
и длинные
значения.
Надеюсь, что это помогает! :)
Вы можете редактировать ваш второй пример кода:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
Просто небольшая модификация вашего первого решения будет достаточно.
Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);
Подробнее здесь для осуществления случайных
По Математике.Класс random в Ява на основе 0. Итак, если вы пишете что-то вроде этого:
Random rand = new Random();
int x = rand.nextInt(10);
"х" будет находиться между 0-9
включительно.
Таким образом, учитывая, следующий массив из 25 элементов, код для генерации случайных чисел в диапазоне от 0
(на основе массива) и `массива.длина будет:
String[] i = new String[25];
Random rand = new Random();
int index = 0;
index = rand.nextInt( i.length );
Начиная с меня.длинавернется
25, в
nextInt( я.длина )возвращает число в диапазоне от 0-24
. Другой вариант идет с Математика.Случайный`, которая работает таким же образом.
index = (int) Math.floor(Math.random() * i.length);
Для лучшего понимания, проверить сообщение на форуме случайные промежутки времени (archive.org).
ThreadLocalRandom эквивалент класса java.утиль.Случайные для многопоточной среды. Генерация случайных чисел осуществляется локально в каждом из потоков. Итак, мы имеем лучшую производительность за счет уменьшения конфликтов.
int rand = ThreadLocalRandom.current().nextInt(x,y);
Х,Y - интервалы, например (1,10)
Прости меня за то, привередливых, но решение, предложенное большинством, т. е. мин + ГСЧ.nextInt(макс - мин + 1))
, кажется опасной из-за того, что:
ГСЧ.целое число nextInt(N) в не досягаемости.Массив
.Верным решением будет возвращать правильные результаты для любых мин <= МАКСв [
целое.MIN_VALUE,
целое число.Массив`]. Рассмотрим следующий наивная реализация:
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;
}
Хотя и неэффективно, отмечают, что вероятность успеха в а
петля всегда будет 50% или выше.
Это может быть сделано, просто делаем заявление:
Ява Рандомизатор.генерировать(0,10); //мин ноль, максимум десяти
Ниже приводится ее исходный код
Ява открытый класс рандомизатор { публичный статический тип int генерировать(инт мин,инт Макс) { возврат мин + (инт)(математика.случайный() * ((макс - мин) + 1)); } }
Это просто чистый и простой.
Интересно, если какой-либо из случайных чисел, генерация методов, предоставляемых [Апач Викискладе математика] библиотекаматематика будет соответствовать всем требованиям.
Например: RandomDataGenerator.nextInt
или RandomDataGenerator.nextLong
Давайте брать пример.
Предположим, я хочу, чтобы генерировать число между 5-10:
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);
Давайте понять это...
и ГТ; > инициализация максимум с высшей ценностью и мин с самой низкой стоимостью.
теперь мы должны определить, сколько возможных значений может быть получена. Для этого примера это будет:
5, 6, 7, 8, 9, 10
и ГТ; > Поэтому, граф, это будет макс - мин + 1.
т. е. 10 - 5 + 1 = 6
случайных чисел генерирует число между 0-5.
т. е. 0, 1, 2, 3, 4, 5
добавление мин значения случайных чисел позволит:
5, 6, 7, 8, 9, 10
и ГТ; > отсюда и получаем нужный диапазон.
rand.nextInt((max+1) - min) + min;
Сгенерировать случайное число, для разница min и Max с помощью nextint(Н) метод, а затем добавить минимальное число к результату:
Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
начиная с Java 7, Вы больше не должны использовать "случайные". Для большинства применений, в генератор случайных чисел выбор сейчас
ThreadLocalRandom
.<БР/><БР/>для развилки присоединиться бассейны и параллельно потоки, использоватьSplittableRandom
.
Джошуа Блох. Эффективная Java. Третье Издание.
Для вилки присоединиться бассейны и параллельных потоков, использовать SplittableRandom которое, как правило, быстрее, лучше, статистическая независимость и равномерность свойств по сравнению с случайный
.
Для генерации случайных инт
в серии [0, 1_000]:
int n = new SplittableRandom().nextInt(0, 1_001);
Для генерации случайного типа int[100]
массив значений в диапазон[0, 1_000]:`
int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
Чтобы вернуть поток случайных значений:
IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
Этот метод может быть удобен в использовании:
Этот метод будет возвращать случайное число между приведенные минимальное и максимальное значение:
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;
}
}
и этот метод будет возвращать случайное число от указана минимальное и максимальное значения (так что сгенерированное число также может быть минимальное или максимальное количество):
public static int getRandomNumberFrom(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt((max + 1) - min) + min;
return randomNumber;
}
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Или взгляните на RandomUtils от Апач Викискладе.
Здесь'ы полезный класс для генерации случайных `целых чисел в диапазоне с любой комбинацией инклюзивную/эксклюзивную границы:
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;
}
}