Как генерировать случайные целые числа в определенном диапазоне в 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`.
 
вопрос задан 12.12.2008
user42155
18034 репутация

61 ответов


  • 3301 рейтинг

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

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

    ответ дан Greg Case, с репутацией 35759, 12.12.2008
  • 1339 рейтинг

    Обратите внимание, что этот подход более предвзятый и менее эффективный, чем подход 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) , где «Макс-Мин» не включен.

    Например, если вы хотите [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))
     
    ответ дан TJ_Fischer, с репутацией 13962, 12.12.2008
  • 313 рейтинг

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

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

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

    ответ дан Matt R, с репутацией 1472, 4.09.2009
  • 125 рейтинг

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

     minimum + rn.nextInt(maxValue - minvalue + 1)
     
    ответ дан krosenvold, с репутацией 51204, 12.12.2008
  • 102 рейтинг

    С помощью они ввели метод 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 значений.

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

    ответ дан Alexis C., с репутацией 65016, 26.11.2014
  • 90 рейтинг

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

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

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

    ответ дан hexabunny, с репутацией 1199, 12.03.2015
  • 90 рейтинг

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

     Random rn = new Random();
    int range = maximum - minimum + 1;
    int randomNum =  rn.nextInt(range) + minimum;
     
    ответ дан Bill the Lizard, с репутацией 283013, 12.12.2008
  • 57 рейтинг

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

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

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

    ответ дан andrew, с репутацией 1885, 12.02.2013
  • 53 рейтинг

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

    ответ дан Matt R, с репутацией 1472, 8.01.2009
  • 43 рейтинг

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

    ответ дан Joel Sjöstrand, с репутацией 547, 10.01.2011
  • 25 рейтинг

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

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

    ответ дан Chinnery, с репутацией 8784, 12.12.2008
  • 25 рейтинг

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

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

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

    ответ дан Sunil Chawla, с репутацией 291, 3.08.2014
  • 21 рейтинг
     rand.nextInt((max+1) - min) + min;
    
    ответ дан Michael Myers, с репутацией 151237, 12.12.2008
  • 18 рейтинг

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

     Random rn = new Random();
    int result = rn.nextInt(max - min + 1) + min;
    System.out.println(result);
     
    ответ дан gifpif, с репутацией 3171, 27.05.2015
  • 17 рейтинг

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

    Для соединений fork join и параллельных потоков используйте 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);
     
    ответ дан Oleksandr, с репутацией 7075, 11.04.2018
  • 17 рейтинг

    Вот полезный класс для генерации случайного 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;
        }
    }
     
    ответ дан Garrett Hall, с репутацией 22843, 15.02.2012
  • 16 рейтинг

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

     face = 1 + randomNumbers.nextInt(6);
     
    ответ дан sam, с репутацией 169, 16.02.2010
  • 16 рейтинг

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

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

     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;
    }
     
    ответ дан Luke Taylor, с репутацией 5115, 12.08.2012
  • 15 рейтинг

    Вы можете добиться этого на 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);
     
    ответ дан Mulalo Madida, с репутацией 201, 20.06.2017
  • 15 рейтинг
     int random = minimum + Double.valueOf(Math.random()*(maximum-minimun)).intValue();
     

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

    ответ дан user2427, с репутацией 3816, 12.12.2008
  • 14 рейтинг

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

    ответ дан raupach, с репутацией 2435, 13.12.2008
  • 14 рейтинг

    Просто используйте класс Random :

     Random ran = new Random();
    // Assumes max and min are non-negative.
    int randomInt = min + ran.nextInt(max - min + 1);
     
    ответ дан Prof Mo, с репутацией 320, 24.12.2013
  • 14 рейтинг
    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);
    }
    
    ответ дан AZ_, с репутацией 24356, 13.07.2011
  • 14 рейтинг

    Вот простой пример, который показывает, как генерировать случайное число из замкнутого диапазона [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;
        }
    }
     
    ответ дан Yakiv Mospan, с репутацией 6643, 28.11.2014
  • 14 рейтинг

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


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

     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.
     
    ответ дан Hospes, с репутацией 334, 7.06.2012
  • 13 рейтинг

    Другой вариант - просто использовать 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);
        // ...
     }
     
    ответ дан gerardw, с репутацией 2680, 18.01.2012
  • 11 рейтинг
     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;
    }
     
    ответ дан Muhammad Aamir Talib, с репутацией 389, 11.02.2015
  • 11 рейтинг

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

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

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

    ответ дан Abel Callejo, с репутацией 4354, 1.09.2013
  • 11 рейтинг

    Лучше использовать 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;
    }
     
    ответ дан grep, с репутацией 2031, 26.03.2015
  • 9 рейтинг
     rand.nextInt((max+1) - min) + min;
     

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

    ответ дан ganesh, с репутацией 99, 22.02.2010
  • 8 рейтинг
    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;
        }
    }
    
    ответ дан ybn, с репутацией 588, 14.06.2014
  • 7 рейтинг

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

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

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

    ответ дан sachit, с репутацией 655, 27.10.2012
  • 6 рейтинг

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

      /**
       * @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, если хотите. Надеюсь, поможет :)

    ответ дан Simo, с репутацией 307, 28.05.2017
  • 6 рейтинг

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

     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.

    ответ дан Lawakush Kurmi, с репутацией 889, 2.11.2017
  • 6 рейтинг

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

     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));
        }
    }
     
    ответ дан thangaraj, с репутацией 179, 8.04.2015
  • 6 рейтинг

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

    Решение 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;
     

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

    ответ дан Jorge, с репутацией 674, 15.01.2014
  • 5 рейтинг

    Другой подход с использованием 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)
    }
     
    ответ дан firephil, с репутацией 581, 21.12.2016
  • 5 рейтинг

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

     RandomStringUtils.randomNumeric(int count)
     

    метод, который также относится к apache.

    ответ дан false9striker, с репутацией 1541, 2.12.2016
  • 4 рейтинг
    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));
        }
    
    }
    
    ответ дан vaquar khan, с репутацией 2592, 31.05.2018
  • 4 рейтинг

    Я думаю, что линейно нормализовать генерируемые случайные числа в желаемый диапазон, используя следующее. Пусть 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);
    }
     
    ответ дан Akash Malhotra, с репутацией 186, 24.11.2013
  • 4 рейтинг

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

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

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

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

    ответ дан jatin3893, с репутацией 521, 27.10.2012
  • 3 рейтинг

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

     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);
        }
    }
     
    ответ дан Akash Malhotra, с репутацией 186, 23.09.2013
  • 3 рейтинг

    В приведенном ниже коде генерируется случайное число от 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);
     
    ответ дан BMAM, с репутацией 39, 1.02.2018
  • 3 рейтинг

    Вы можете использовать класс 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;
     
    ответ дан f310r, с репутацией 198, 24.05.2014
  • 3 рейтинг

    Это будет генерировать список случайных чисел с диапазоном (Min - Max) без дубликата .

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

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

    ответ дан Hiren Patel, с репутацией 34277, 26.09.2016
  • 3 рейтинг

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

     /*
          * 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;
    }
     
    ответ дан Xar E Ahmer, с репутацией 21729, 19.01.2017
  • 3 рейтинг

    Это довольно простой ответ.

    -> Предположим, вы хотите, чтобы диапазон между 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);
    }
     
    ответ дан Siddhartha Thota, с репутацией 306, 25.02.2018
  • 3 рейтинг

    Один из моих друзей задал мне тот же вопрос в университете сегодня (его требования состояли в том, чтобы создать случайное число между 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));
     
    ответ дан Arun Abraham, с репутацией 1727, 5.12.2012
  • 3 рейтинг

    Ниже приведен еще один пример использования 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);
     
    ответ дан Sanjeev Singh, с репутацией 41, 23.05.2018
  • 2 рейтинг

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

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

    Он имеет краевое включение /исключение.

    ответ дан ledlogic, с репутацией 309, 1.12.2017