it-swarm.com.ru

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

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

В 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 instance, который может стать источником путаницы и ошибок, если используется не по назначению.

Однако, наоборот, нет способа явно установить начальное число, поэтому может быть трудно воспроизвести результаты в ситуациях, когда это полезно, таких как тестирование или сохранение игровых состояний или тому подобное. В этих ситуациях может использоваться методика до 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 для выполнения задачи.

3508
Greg Case

Обратите внимание, что этот подход является более предвзятым и менее эффективным, чем подход nextInt, https://stackoverflow.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), где «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))
1365
TJ_Fischer

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

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

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

327
jackson

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

minimum + rn.nextInt(maxValue - minvalue + 1)
137
krosenvold

С 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.

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

113
Alexis C.

Вы можете отредактировать свой второй пример кода:

Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;
98
Bill the Lizard

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

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

Смотрите больше здесь для реализации Random

93
hexabunny

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

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

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

60
andrew

Класс 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).

60
Matt R

Прости меня за привередливость, но решение, предложенное большинством, то есть 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% или выше.

46
Joel Sjöstrand

Интересно, подойдет ли какой-либо из методов генерации случайных чисел, предоставляемых библиотекой Apache Commons Math

Например: RandomDataGenerator.nextInt или RandomDataGenerator.nextLong

29
Chinnery

Давайте возьмем пример.

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

Таким образом, счет этого будет макс - мин + 1. 

то есть 10 - 5 + 1 = 6

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

то есть 0, 1, 2, 3, 4, 5

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

5, 6, 7, 8, 9, 10 

Отсюда получаем желаемый диапазон. 

28
Sunil Chawla
 Rand.nextInt((max+1) - min) + min;
24
Michael Myers

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

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

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

Для пулов вил и соединения параллельно потоки, используйте SplittableRandom .

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

Начиная с Java 8

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

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

face = 1 + randomNumbers.nextInt(6);
18
sam

Вот полезный класс для генерации случайных ints в диапазоне с любой комбинацией включающих/исключающих границ:

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;
    }
}
18
Garrett Hall
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

Или взгляните на RandomUtils из Apache Commons .

18
user2427

Чтобы сгенерировать случайное число «между двумя числами», используйте следующий код:

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

Это дает вам случайное число от 1 (включительно) до 11 (исключение), поэтому инициализируйте значение upperBound, добавив 1. Например, если вы хотите сгенерировать случайное число от 1 до 10, инициализируйте число upperBound с 11 вместо 10.

17
Lawakush Kurmi

Эти методы могут быть удобны в использовании:

Этот метод вернет случайное числомеждупредоставленным минимальным и максимальным значением:

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;
}
17
Luke Taylor

Просто используйте Случайный класс: 

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
16
Prof Mo

Я нашел этот пример Генерация случайных чисел


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

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.
16
Hospes

Вы можете достичь этого кратко в 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);
15
Mulalo Madida

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

15
raupach
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);
}
15
AZ_

Другой вариант - просто использовать 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);
    // ...
 }
14
gerardw

Вот простой пример, который показывает, как генерировать случайное число из закрытого диапазона [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;
    }
}
13
Yakiv Mospan
private static Random random = new Random();    

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

OR

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

Если вы хотите попробовать ответ с большинством голосов выше, вы можете просто использовать этот код:

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

Это просто чисто и просто.

11
Abel Callejo

Лучше использовать SecureRandom , чем просто Random.

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;
}
11
grep
Rand.nextInt((max+1) - min) + min;

Это работает нормально. 

11
ganesh

Я использую это:

 /**
   * @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;
 }

Вы можете привести его к Integer, если хотите.

9
Simon
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;
    }
}
8
ybn

Вы можете сделать что-то вроде этого:

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

Вы можете использовать этот фрагмент кода, который решит вашу проблему: 

Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;

Используйте myRandomNumber (который даст вам номер в диапазоне).

7
sachit

Другой подход с использованием Java 8 IntStream и Collections.shuffle

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

Эквивалент в Scala

import scala.util.Random

object RandomRange extends App{
  val x =  Random.shuffle(5 to 10)
    println(x)
}
6
firephil

Я просто скажу, что не так с решениями, предоставленными вопросом, и почему ошибки. 

Решение 1:

randomNum = minimum + (int)(Math.random()*maximum); 

Проблема: для randomNum присваиваются значения чисел больше максимального.

Объяснение: Предположим, что наш минимум равен 5, а ваш максимум равен 10. Любое значение из Math.random() больше 0,6 заставит выражение оценить значение 6 или больше, а добавление 5 сделает его больше 10 (ваш максимум). Проблема в том, что вы умножаете случайное число на максимум (который генерирует число, почти равное максимуму), а затем добавляете минимум. Если минимум не равен 1, это не правильно. Вы должны переключиться на, как указано в других ответах

randomNum = minimum + (int)(Math.random()*(maximum-minimum+1))

+1 потому что Math.random() никогда не вернет 1.0.

Решение 2:

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;

Ваша проблема здесь в том, что «%» может вернуть отрицательное число, если первый член меньше 0. Так как rn.nextInt() возвращает отрицательные значения с вероятностью ~ 50%, вы также не получите ожидаемый результат.

Это было, однако, почти идеально. Вам просто нужно было посмотреть немного дальше вниз по Javadoc, nextInt (int n) . С этим методом доступны, делая

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt(n);
randomNum =  minimum + i;

Также вернул бы желаемый результат.

6
Jorge
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
5
namezhouyu

Вы могли бы использовать 

RandomStringUtils.randomNumeric(int count)

метод также из Apache Commons. 

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

}

Вы также можете использовать 

import Java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();

Однако этот класс не очень хорошо работает в многопоточной среде.

4
vaquar khan

Внесение следующих изменений в Попытка 1 должно сделать работу - 

randomNum = minimum + (int)(Math.random() * (maximum - minimum) );

Проверьте это для рабочего кода.

4
monster

Я думаю, чтобы линейно нормализовать сгенерированные случайные числа в желаемом диапазоне, используя следующее. Пусть x будет случайным числом, пусть a и b будут минимальным и максимальным диапазоном желаемого нормализованного числа.

Ниже приведен лишь очень простой фрагмент кода для проверки диапазона, получаемого линейным отображением.

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

Я просто генерирую случайное число с помощью Math.random () и умножаю его на большое число, скажем, 10000. Итак, я получаю число от 0 до 10000 и называю это число i. Теперь, если мне нужны числа между (x, y), сделайте следующее:

i = x + (i % (y - x));

Итак, все i являются числами от x до y.

Чтобы убрать смещение, как указано в комментариях, вместо умножения его на 10000 (или большого числа), умножьте его на (y-x).

4
jatin3893

Я думаю, что этот код будет работать для него. Пожалуйста, попробуйте это: 

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);
    }
}
3
Akash Malhotra

Если вы уже используете Commons Lang API 2.x или последнюю версию, тогда существует один класс для генерации случайных чисел RandomUtils.

public static int nextInt(int n)

Возвращает псевдослучайное, равномерно распределенное значение типа int между 0 (включительно) и указанным значением (исключая) из последовательности Math.random ().

Параметры: n - указанное эксклюзивное максимальное значение

int random = RandomUtils.nextInt(1000000);

Примечание: в RandomUtils есть много методов для генерации случайных чисел 

3
Divyesh Kanzariya

Приведенный ниже код генерирует случайное число от 100 000 до 900 000. Этот код будет генерировать шестизначные значения. Я использую этот код для генерации шестизначного OTP .

Используйте import Java.util.Random, чтобы использовать этот случайный метод.

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

Вы можете использовать класс Random для генерации случайного числа, а затем использовать .nextInt (maxNumber) для генерации случайного числа. MaxNumber - это число, которое вы хотите максимум при генерации случайного числа. Пожалуйста, помните, что класс Random дает вам числа от 0 до maxNumber-1. 

Random r = new Random();
int i = r.nextInt();

Другой способ сделать это - использовать класс Math.Random (), который требуется от многих классов в школах, потому что он более эффективен и вам не нужно объявлять новый объект Random. Чтобы получить случайное число с помощью Math.Random (), введите:

Math.random() * (max - min) + min;
3
f3d0r

Будет сгенерирован список случайных чисел с range (Min - Max) с no duplicate.

generateRandomListNoDuplicate(1000, 8000, 500);

Добавьте этот метод.

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

Надеюсь, что это поможет вам.

3
Hiren Patel

Я создал метод, чтобы получить уникальное целое число в заданном диапазоне.

/*
      * 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;
}
3
Xar E Ahmer

Допустим, вы хотите диапазон от 0 до 9, 0 - это минимум, а 9 - максимум. Приведенная ниже функция будет печатать что угодно в диапазоне от 0 до 9. Она одинакова для всех диапазонов.

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);
}
3
Siddhartha Thota

Один из моих друзей задал мне этот же вопрос сегодня в университете (его требованием было сгенерировать случайное число между 1 и -1). Итак, я написал это, и пока все отлично работает с моим тестированием. В идеале существует множество способов генерирования случайных чисел с заданным диапазоном. Попробуй это: 

Функция:

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

Выполните так:

System.out.println( getRandomNumberBetween(1,-1));
3
Arun Abraham

Ниже приведен еще один пример использования Random и forEach.

int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
3
Sanjeev Singh

Есть библиотека по адресу https://sourceforge.net/projects/stochunit/ для обработки выбора диапазонов.

StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();

Имеет Edge-включение/исключение.

2
ledlogic

Простой способ генерировать n случайных чисел между a и b Например, a = 90, b = 100, n = 20

Random r = new Random();
for(int i =0; i<20; i++){
    System.out.println(r.ints(90, 100).iterator().nextInt());
}

r.ints() возвращает IntStream и имеет несколько полезных методов, посмотрите на его API .

2
Sam2016

Попробуйте использовать класс org.Apache.commons.lang.RandomStringUtils. Да, иногда он дает повторяющееся число рядом, но это даст значение от 5 до 15:

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

Случайное число из диапазона [min..max] включительно:

int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
        .nextInt(min, max + 1);
2
Andrey

Используйте Java.util для Random для общего пользования.

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

Random Rand=new Random();
Rand.nextInt((max+1) - min) + min;
2
Prakhar Nigam

Большинство из вышеперечисленных предложений не учитывают «переполнение», например: min = Integer.MIN_VALUE, max = 100. Один из правильных подходов, которые у меня есть, заключается в следующем:

final long mod = max- min + 1L;
final int next = (int) (Math.abs(Rand.nextLong() % mod) + min);
2
user_3380739

Это простой способ сделать это.

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

Там 5 является отправной точкой случайных чисел. 6 - это диапазон, включающий номер 5.

2
Gihan Chathuranga
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);

}
1
Alekya

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

0
Arth Tyagi

Используя Java 8 Streams,

  • Передайте initialCapacity - Сколько чисел
  • Передайте randomBound - от x до randomBound
  • Передайте true/false для отсортированных или нет
  • Передать новый объект Random ()

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

В этом примере он генерирует числа из 1-Randombound.

0
Jake O

Ниже приведен пример класса, который показывает, как генерировать случайные целые числа в пределах определенного диапазона. Присвойте любое значение, которое вы хотите, в качестве максимального значения переменной 'max', и присвойте любое значение, которое вы хотите, в качестве минимального значения переменной 'min'.

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

}
0
Anjali Pavithra

Следующий код может быть использован:

ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
0
anshul