Как генерировать случайные целые числа в определенном диапазоне в 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'.
+3255
12 дек. '08 в 18:20
источник поделиться
67 ответов
  • 1
  • 2
  • 3
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;
}
+12
11 февр. '15 в 11:40
источник

Связанные вопросы


Похожие вопросы

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

 /**
   * @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
28 мая '17 в 14:30
источник
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
14 июн. '14 в 3:50
источник

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

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
08 апр. '15 в 14:14
источник

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

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

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

+7
27 окт. '12 в 8:07
источник

Другой подход с использованием 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
21 дек. '16 в 23:37
источник

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

Решение 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
15 янв. '14 в 0:51
источник
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
+5
09 окт. '17 в 8:48
источник

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

RandomStringUtils.randomNumeric(int count)

который также относится к апасам.

+5
02 дек. '16 в 18:16
источник

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

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

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

+4
14 авг. '18 в 12:25
источник

Я имею в виду линейную нормализацию порожденных случайных чисел в желаемый диапазон, используя следующее. Пусть 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
24 нояб. '13 в 14:15
источник

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

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

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

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

+4
27 окт. '12 в 8:17
источник
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
31 мая '18 в 15:16
источник

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

public static int nextInt(int n)

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

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

int random = RandomUtils.nextInt(1000000);

Примечание. В RandomUtils есть много способов генерации случайных чисел

+3
26 мая '17 в 13:24
источник

Вы можете использовать класс 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
24 мая '14 в 23:21
источник

Один из моих друзей задал мне тот же вопрос в университете сегодня (его требования состояли в том, чтобы создать случайное число от 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
05 дек. '12 в 17:28
источник

Ниже приведен еще один пример использования 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
23 мая '18 в 15:24
источник

Допустим, вы хотите диапазон от 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
25 февр. '18 в 20:26
источник

В приведенном ниже коде генерируется случайное число от 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
01 февр. '18 в 4:54
источник

Это приведет к списку случайных чисел с диапазоном (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);
    }
}

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

+3
26 сент. '16 в 20:13
источник

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

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
23 сент. '13 в 9:24
источник

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

/*
      * 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
19 янв. '17 в 6:37
источник

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

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.

+3
12 авг. '17 в 14:10
источник

Попробуйте использовать класс 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
07 июн. '13 в 15:14
источник
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);

}
+2
22 авг. '18 в 6:46
источник

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

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

Random rand=new Random();
rand.nextInt((max+1) - min) + min;
+2
17 нояб. '18 в 7:46
источник

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

final long mod = max- min + 1L;
final int next = (int) (Math.abs(rand.nextLong() % mod) + min);
+2
28 нояб. '16 в 22:33
источник

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

int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
        .nextInt(min, max + 1);
+2
29 окт. '15 в 20:46
источник

Простой способ генерации 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
04 окт. '17 в 14:18
источник

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

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

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

+2
01 дек. '17 в 23:01
источник
  • 1
  • 2
  • 3

Посмотрите другие вопросы по меткам или Задайте вопрос