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

В 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); //мин ноль, максимум десяти

Ниже приводится ее исходный код

Randomizer.java

Ява открытый класс рандомизатор { публичный статический тип 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

и ГТ; > отсюда и получаем нужный диапазон.

Сгенерировать случайное число, для разница min и Max с помощью nextint(Н) метод, а затем добавить минимальное число к результату:

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

начиная с Java 7, Вы больше не должны использовать "случайные". Для большинства применений, в генератор случайных чисел выбор сейчас ThreadLocalRandom.<БР/><БР/>для развилки присоединиться бассейны и параллельно потоки, использовать SplittableRandom.

Джошуа Блох. Эффективная Java. Третье Издание.

Начиная с Java 8

Для вилки присоединиться бассейны и параллельных потоков, использовать 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;
}

В случае прокатки кости это будет случайное число от 1 до 6 (от 0 до 6), так:

face = 1 + randomNumbers.nextInt(6);

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;
    }
}