如何在Java中生成特定范围内的随机整数?

时间:2008-12-12 18:20:57

标签: java random integer

如何在特定范围内生成随机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`.

70 个答案:

答案 0 :(得分:3564)

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

the relevant JavaDoc。这种方法的优点是不需要显式初始化java.util.Random实例,如果使用不当,可能会造成混淆和错误。

然而,相反,没有办法明确设置种子,因此很难在有用的情况下重现结果,例如测试或保存游戏状态或类似情况。在这些情况下,可以使用下面显示的Java之前的1.7技术。

在Java 1.7 之前,执行此操作的标准方法如下:

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

the relevant JavaDoc。在实践中,java.util.Random类通常优于java.lang.Math.random()

特别是,当标准库中有一个简单的API来完成任务时,不需要重新发明随机整数生成轮。

答案 1 :(得分:1381)

请注意,与nextInt方法https://stackoverflow.com/a/738651/360211

相比,此方法更具偏见且效率更低

实现这一目标的一个标准模式是:

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

Java数学库函数Math.random()在[0,1)范围内生成一个double值。请注意,此范围不包括1。

为了首先获得特定范围的值,您需要乘以您想要覆盖的值范围的大小。

Math.random() * ( Max - Min )

这会返回[0,Max-Min)范围内的值,其中不包含'Max-Min'。

例如,如果您需要[5,10),则需要覆盖五个整数值,以便使用

Math.random() * 5

这将返回[0,5)范围内的值,其中不包括5。

现在您需要将此范围向上移动到您定位的范围。您可以通过添加最小值来完成此操作。

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

您现在将获得[Min,Max)范围内的值。按照我们的示例,这意味着[5,10)

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

但是,这仍然不包括Max,你得到的是双倍价值。为了获得Max值,您需要在范围参数(Max - Min)中加1,然后通过强制转换为int来截断小数部分。这是通过以下方式完成的:

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

你有它。 [Min,Max]范围内的随机整数值,或每个示例[5,10]

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

答案 2 :(得分:336)

使用:

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

整数x现在是可能结果为5-10的随机数。

答案 3 :(得分:142)

使用:

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

答案 4 :(得分:115)

使用,他们在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();
    }
}

您也可以为doublelong值执行此操作。

希望它有所帮助! :)

答案 5 :(得分:100)

您可以将第二个代码示例编辑为:

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

答案 6 :(得分:97)

只需对您的第一个解决方案进行一点修改即可。

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

请点击此处查看Random

的实施情况

答案 7 :(得分:62)

ThreadLocalRandom等效于多线程环境的类java.util.Random。在每个线程中本地执行生成随机数。因此,通过减少冲突,我们可以获得更好的表现。

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

x,y - 间隔例如(1,10)

答案 8 :(得分:61)

Java中的Math.Random类基于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将返回25nextInt( i.length )将返回0-24范围之间的数字。另一个选项是Math.Random,它的工作方式相同。

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

为了更好地理解,请查看论坛帖子 Random Intervals (archive.org)

答案 9 :(得分:48)

请原谅我的挑剔,但多数人建议的解决方案,即min + rng.nextInt(max - min + 1)),似乎是危险的,因为:

  • rng.nextInt(n)无法访问Integer.MAX_VALUE
  • (max - min)为否定时,
  • min可能会导致溢出。

一个万无一失的解决方案会为[min <= maxInteger.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%或更高。

答案 10 :(得分:33)

我想知道Apache Commons Math库提供的任何随机数生成方法是否符合要求。

例如:RandomDataGenerator.nextIntRandomDataGenerator.nextLong

答案 11 :(得分:31)

可以通过简单地做声明来完成:

Randomizer.generate(0,10); //min of zero, max of ten

以下是其源代码

Randomizer.java

public class Randomizer
{
    public static int generate(int min,int max)
    {
        return min + (int)(Math.random() * ((max - min) + 1));
    }
}

它干净简单。

答案 12 :(得分:30)

让我们举个例子。

假设我希望在 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

    
         

因此我们获得了所需的范围。

  

答案 13 :(得分:27)

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

答案 14 :(得分:22)

使用nextint(n)方法生成最小值和最大值之差的随机数,然后在结果中添加最小数字:

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

答案 15 :(得分:21)

  

从Java 7开始,您不应再使用Random。对于大多数用途,   现在选择随机数发生器   ThreadLocalRandom

对于fork join pool和parallel   流,使用SplittableRandom

Joshua Bloch。有效的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);

答案 16 :(得分:19)

如果掷骰子,它将是1到6之间的随机数(不是0到6),所以:

face = 1 + randomNumbers.nextInt(6);

答案 17 :(得分:19)

这是一个有用的类,可以在包含/包含任意组合的范围内生成随机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 :(得分:19)

int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

或者查看来自Apache Commons的RandomUtils。

答案 19 :(得分:19)

这种方法可能很方便使用:

此方法将在 之间返回一个随机数 提供的最小值和最大值:

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

答案 20 :(得分:18)

要在两个数字&#34;之间生成随机数&#34;,请使用以下代码:

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

这为您提供1(包括)和11(不包括)之间的随机数,因此通过添加1来初始化upperBound值。例如,如果要生成1到10之间的随机数,则使用以下方法初始化upperBound数: 11而不是10。

答案 21 :(得分:17)

You can achieve that concisely in 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);

答案 22 :(得分:17)

只需使用Random类:

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

答案 23 :(得分:17)

我找到了这个例子Generate random numbers


此示例生成特定范围内的随机整数。

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.

答案 24 :(得分:16)

当您需要大量随机数时,我不推荐API中的Random类。这个时期太短了。请尝试使用Mersenne twister。有a Java implementation

答案 25 :(得分:16)

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

答案 26 :(得分:15)

另一种选择是使用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);
    // ...
 }

答案 27 :(得分: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;
    }
}

答案 28 :(得分:13)

最好使用SecureRandom而不仅仅是随机。

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

答案 29 :(得分:12)

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

答案 30 :(得分:12)

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

这很好用。

答案 31 :(得分:9)

我用这个:

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

如果需要,可以将其强制转换为整数。

答案 32 :(得分: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;
    }
}

答案 33 :(得分:7)

您可以这样做:

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

答案 34 :(得分:7)

您可以使用此代码段来解决您的问题:

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

使用myRandomNumber(它会给你一个范围内的数字)。

答案 35 :(得分:6)

使用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)
}

答案 36 :(得分: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%,因此您也无法得到预期结果。< / p>

然而,这几乎是完美的。你只需要看一下Javadoc,nextInt(int n)。使用该方法,执行

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

也会返回所需的结果。

答案 37 :(得分:5)

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

答案 38 :(得分:5)

您可以使用

RandomStringUtils.randomNumeric(int count)

方法也来自apache commons。

答案 39 :(得分: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));
    }

}

您也可以使用

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

但是,这个类在多线程环境中表现不佳。

答案 40 :(得分:4)

尝试1 中进行以下更改即可完成工作-

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

检查this以获取工作代码。

答案 41 :(得分:4)

我想通过使用以下方法将生成的随机数线性归一化到所需范围。设x为随机数,让ab为所需标准化数字的最小和最大范围。

然后下面是一个非常简单的代码片段,用于测试线性映射产生的范围。

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

答案 42 :(得分:4)

我只是使用Math.random()生成一个随机数,然后乘以一个大数字,比方说10000.所以,我得到一个介于0到10,000之间的数字并调用这个数字i。现在,如果我需要(x,y)之间的数字,那么请执行以下操作:

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

因此,所有i都是x和y之间的数字。

要删除评论中指出的偏见,而不是将其乘以10000(或大数字),请将其乘以(y-x)。

答案 43 :(得分: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);
    }
}

答案 44 :(得分:3)

如果您已使用Commons Lang API 2.x或最新版本,那么有一个用于生成随机数的类RandomUtils

public static int nextInt(int n)

从Math.random()序列返回伪随机,在0(包括)和指定值(不包括)之间均匀分布的int值。

参数: n - 指定的独占最大值

int random = RandomUtils.nextInt(1000000);

注意:在RandomUtils中有许多随机数生成方法

答案 45 :(得分: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);

答案 46 :(得分: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;

答案 47 :(得分:3)

这将生成随机数列表范围(最小 - 最大)无重复

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

希望这会对你有所帮助。

答案 48 :(得分: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;
}

答案 49 :(得分: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);
}

答案 50 :(得分:3)

使用Apache Lang3 Commons

Integer.parseInt(RandomStringUtils.randomNumeric(6, 6));

最小值100000至最大值999999

答案 51 :(得分: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));

答案 52 :(得分: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);

答案 53 :(得分:2)

https://sourceforge.net/projects/stochunit/有一个库用于处理范围的选择。

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

它有边缘包含/排除。

答案 54 :(得分:2)

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

}

答案 55 :(得分:2)

在a和b之间生成n个随机数的简单方法 例如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

答案 56 :(得分:2)

尝试使用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;
        }
    }

答案 57 :(得分:2)

int func(int max, int min){

      int range = max - min + 1;
      
      // Math.random() function will return a random no between [0.0,1.0).
      int res = (int) ( Math.random()*range)+min;

      return res;
}

答案 58 :(得分:2)

[min..max]范围内的随机数:

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

答案 59 :(得分:2)

将java.util用于一般随机使用。

您可以定义最小和最大范围来获得这些结果。

Random rand=new Random();
rand.nextInt((max+1) - min) + min;

答案 60 :(得分:2)

上述大多数建议都不考虑溢出&#39;,例如:min = Integer.MIN_VALUE,max = 100.到目前为止,我所采用的正确方法之一是:

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

答案 61 :(得分:2)

您可以使用以下方式进行操作

int range = 10;
int min = 5
Random r = new Random();
int  = r.nextInt(range) + min;

答案 62 :(得分:1)

使用math.random()并在if语句中设置要求。最简单,最简单,最快的方法

答案 63 :(得分:1)

使用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生成数字。

答案 64 :(得分:0)

这是一个函数,该函数将根据要求由 lowerBoundIncluded upperBoundIncluded 定义的范围内恰好返回一个整数随机数 user42155

SplittableRandom splittableRandom = new SplittableRandom();

BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
    -> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );

randomInt.apply( …, … ); // gets the random number

答案 65 :(得分:0)

import java.util.Random;
public class Main
{
    public static void main(String[] args) {
        Random rand = new Random();
        System.out.printf("%04d%n", rand.nextInt(10000));
    }
}

答案 66 :(得分:0)

下面是一个示例类,显示了如何生成特定范围内的随机整数。将所需的任何值作为最大值分配给变量“ 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);
    }

}

答案 67 :(得分:0)

可以使用以下代码:

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

答案 68 :(得分:0)

这是非常简单的代码,它生成介于1和变量maximum之间的随机数,然后确定该随机数是否小于minimum。 如果答案是肯定的,则将minimum添加到随机数。然后返回数字。

 public static int random(int minimum, int maximum) {
            int i = (int) (Math.random() * maximum);
            if (i < minimum) {
                return i + minimum;
            } else {
                return i;
            }
        }

答案 69 :(得分:-1)

public static int getRandomNumberInts(int min, int max){ Random random = new Random(); return random.ints(min,(max+1)).findFirst().getAsInt(); }

我们可以尝试使用Java 8中新的random.ints函数来解决它。

寻找你感兴趣的贴纸↓↓↓
豫ICP备18024241号-1