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




заполнение массива случайными числами java (20)

Начиная с Java 7, вы больше не должны использовать Random . Для большинства применений генератором случайных чисел является ThreadLocalRandom .

Для пулов объединения fork и параллельных потоков используйте SplittableRandom .

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

Начиная с Java 8

Для пулов объединения fork и параллельных потоков используйте SplittableRandom который, как правило, быстрее, обладает лучшими статистическими независимыми и однородными свойствами по сравнению с Random .

Чтобы создать случайный int в диапазоне [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);

https://code.i-harness.com

Как создать случайное значение 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`.

ThreadLocalRandom эквивалент класса java.util.Random для многопоточной среды. Генерация случайного числа выполняется локально в каждом из потоков. Таким образом, мы имеем лучшую производительность за счет сокращения конфликтов.

int rand = ThreadLocalRandom.current().nextInt(x,y);

x, y - интервалы, например (1,10)


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

face = 1 + randomNumbers.nextInt(6);

Возьмем пример.

Предположим, что я хочу сгенерировать число между 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);

Давайте поймем это ...

Инициализируйте max с наивысшим значением и min с самым низким значением.

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

5, 6, 7, 8, 9, 10

Таким образом, это будет max - min + 1.

т.е. 10 - 5 + 1 = 6

Случайное число будет генерировать число от 0 до 5 .

т.е. 0, 1, 2, 3, 4, 5

Добавление значения min к случайному числу приведет к:

5, 6, 7, 8, 9, 10

Следовательно, мы получаем желаемый диапазон.


Вот простой пример, который показывает, как генерировать случайное число из замкнутого диапазона [min, max] , в то время как min <= max is true

Вы можете использовать его как поле в классе дыр, также имея все методы Random.class в одном месте

Пример результатов:

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

Источники:

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

Вы можете добиться этого на Java 8:

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

Достаточно небольшой модификации вашего первого решения.

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

Подробнее о реализации Random


Другой вариант - просто использовать Apache Commons :

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


Использование:

Random ran = new Random();
int x = ran.nextInt(6) + 5;

Целое число x теперь является случайным числом, которое имеет возможный результат 5-10 .


Класс Math.Random в Java основан на 0. Итак, если вы напишете что-то вроде этого:

Random rand = new Random();
int x = rand.nextInt(10);

x будет находиться между 0-9 включительно.

Итак, учитывая следующий массив из 25 элементов, код для генерации случайного числа между 0 (базой массива) и array.length будет:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

Поскольку i.length вернет 25 , nextInt( i.length ) вернет число между диапазоном 0-24 . Другой вариант идет с Math.Random который работает одинаково.

index = (int) Math.floor(Math.random() * i.length);

Для лучшего понимания, ознакомьтесь с сообщениями форума Случайные интервалы (archive.org) .


Когда вам нужно много случайных чисел, я не рекомендую класс Random в API. У этого есть только слишком маленький период. Вместо этого попробуйте Mersenne twister . Существует реализация Java .


Обратите внимание, что этот подход более предвзятый и менее эффективный, чем подход nextInt , https://.com/a/738651/360211

Один стандартный шаблон для этого:

Min + (int)(Math.random() * ((Max - Min) + 1))

Функция библиотеки Java Math Math.random () генерирует двойное значение в диапазоне [0,1) . Обратите внимание, что этот диапазон не включает 1.

Чтобы сначала получить определенный диапазон значений, вам нужно умножить на величину диапазона значений, которые вы хотите покрыть.

Math.random() * ( Max - Min )

Это возвращает значение в диапазоне [0,Max-Min) , где «Макс-Мин» не включается.

Например, если вы хотите [5,10) , вам нужно покрыть пять целых значений, чтобы вы использовали

Math.random() * 5

Это вернет значение в диапазоне [0,5) , где 5 не включено.

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

Min + (Math.random() * (Max - Min))

Теперь вы получите значение в диапазоне [Min,Max) . Следуя нашему примеру, это означает [5,10) :

5 + (Math.random() * (10 - 5))

Но это все еще не включает Max и вы получаете двойное значение. Чтобы получить значение Max , вам нужно добавить 1 к вашему параметру диапазона (Max - Min) а затем усечь десятичную часть, выполнив кастинг в int. Это достигается посредством:

Min + (int)(Math.random() * ((Max - Min) + 1))

И вот он у вас есть. Случайное целочисленное значение в диапазоне [Min,Max] или в примере [5,10] :

5 + (int)(Math.random() * ((10 - 5) + 1))

Простите меня за брезгливость, но решение, предложенное большинством, т. min + rng.nextInt(max - min + 1)) , кажется опасным из-за того, что:

  • rng.nextInt(n) не может достигнуть Integer.MAX_VALUE .
  • (max - min) может привести к переполнению, когда min отрицательный.

Убедительное решение вернет правильные результаты для любого min <= max внутри [ Integer.MIN_VALUE , Integer.MAX_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;
}

Неэффективны, обратите внимание, что вероятность успеха в цикле while всегда будет 50% или выше.


С помощью java-8 они вводили метод ints(int randomNumberOrigin, int randomNumberBound) в классе Random .

Например, если вы хотите сгенерировать пять случайных целых чисел (или один) в диапазоне [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();
    }
}

Вы также можете сделать это для double и long значений.

Надеюсь, поможет! :)


Создайте случайное число для разности min и max с помощью nextint(n) а затем добавьте минимальное число в результат:

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

Я нашел этот пример. Генерируйте случайные числа :

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

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

Пример выполнения этого класса:

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.

 rand.nextInt((max+1) - min) + min;

private static Random random = new Random();    

public static int getRandomInt(int min, int max){
  return random.nextInt(max - min + 1) + min;
}

ИЛИ ЖЕ

public static int getRandomInt(Random random, int min, int max)
{
  return random.nextInt(max - min + 1) + min;
}

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




integer