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


How do I generate random integers within a specific range in Java?

如何在特定范围内生成随机int值？

我尝试过以下方法，但这些方法不起作用：

尝试1：

1
2
randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

尝试2：

1
2
3
4
5
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.

和Java 1.7或以后的标准方式是这样的：， ＜／P >

1
2
3
4
5
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。这种方法有优势的学院在这一needing explicitly initialize java.util.random审，这可以是一个开源的混乱和错误，如果用inappropriately。 ＜／P >

however conversely是好的，有办法explicitly集的种子是它可以在紧急情况reproduce困难这一结果，这样的测试，是useful为国家节约或游戏或相似。这些紧急情况的预警技术，Java 1.7 shown下面可以用。 ＜／P >

在Java 1.7，标准的方式为：是这样， ＜／P >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <wyn>Integer.MAX_VALUE - 1</wyn>.
 *
 * @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 often preferable java.lang.math.random()。 ＜／P >

特别是，你需要有好的设计reinvent随机整数.当有一straightforward API是在标准库，这accomplish的任务。 ＜／P >

相关讨论

注意，这个方法是可比nextInt击偏置和高效的方法，stackoverflow.com https:/ / / / / 360211 738651 ＜／P >

这是一pattern accomplishing标准为： ＜／P >

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

Java库函数的数学math.random(A)generates双值的范围[0,1)。这个公告是在包括的范围在1。 ＜／P >

这一次，得到的特异性范围的值的第一，你需要通过multiply值的范围的值的你想要的出口。 ＜／P >

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

这returns A值的范围[0,Max-Min)，在"最大最小"是不包括在。 ＜／P >

例如，如果你想[5,10)，你需要包括五个整数的值使用的是你 ＜／P >

1
Math.random() * 5

这将返回一个值的范围是不包括在[0,5)，在5。 ＜／P >

现在你需要转变到这山上的路，你targeting。你对这个adding的最小值。 ＜／P >

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

现在你会得到一个值的范围[Min,Max)。下面，我们[5,10)：例如，均值 ＜／P >

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

但是，这还不包括Max和你得到一双价值。而得到的包括在Max阶值加1，你需要你的范围和(Max - Min)然后截断参数的部分，通过这一国际decimal铸造完成。这是通过： ＜／P >

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

"有你有它。一个随机整数的值的范围[Min,Max]或本身，例如："[5,10] ＜／P >

1
5 + (int)(Math.random() * ((10 - 5) + 1))
相关讨论

使用： ＜／P >

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

"整数x是现在的随机数，有一个可能的结果的5-10。 ＜／P >

使用： ＜／P >

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

通过java-8，他们在Random类中引入了方法ints(int randomNumberOrigin, int randomNumberBound)。

例如，如果要生成范围[0，10]内的五个随机整数(或单个整数)，只需执行以下操作：

1
2
3
Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

第一个参数仅指示生成的IntStream的大小(这是生成无限IntStream的方法的重载方法)。

如果需要执行多个单独的调用，可以从流中创建无限基元迭代器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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值。

希望它有帮助！：)

相关讨论

你可以编辑你的代码，例如：2 ＜／P >

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

只需对第一个解决方案进行一点点修改就足够了。

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

关于Random的实施，请参阅此处的更多信息。

相关讨论

"Math.Random类和java是0型。是的，如果你写什么像这样： ＜／P >

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

x将包括0-9之间。 ＜／P >

令人困惑的是，给定下面的25项目的代码，但这generate之间的随机数0("基地"和array.length阵)将： ＜／P >

1
2
3
4
5
String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

由于i.length25会回来，会返回一个nextInt( i.length )数之间的0-24的范围。"这是要与其他选项Math.Random厂在自己的路。 ＜／P >

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

为一个更好的理解，看看论坛后随机intervals(archive.org)。 ＜／P >

相关讨论

threadLocalRandom相当于多线程环境的java.util.random类。生成一个随机数是在每个线程的本地执行的。因此，通过减少冲突，我们有更好的表现。

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

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

请原谅我太挑剔了，但大多数人(即min + rng.nextInt(max - min + 1))提出的解决方案)似乎很危险，因为：

  • rng.nextInt(n)不能到达Integer.MAX_VALUE。
  • 当min为负时，(max - min)可能导致溢出。

一个简单的解决方案将返回[Integer.MIN_VALUE、Integer.MAX_VALUE内任何min <= max的正确结果。考虑以下幼稚的实施：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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%或更高。

相关讨论

我想知道如果任何的随机数的生成方法提供由一个Apache Commons数学库将合适的法案。 ＜／P >

例如：RandomDataGenerator.nextInt或RandomDataGenerator.nextLong ＜／P >

让我们举个例子。

假设我希望生成一个介于5-10之间的数字：

1
2
3
4
5
6
7
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);

让我们理解这一点…

Initialize max with highest value and min with the lowest value.

Now, we need to determine how many possible values can be obtained. For this example, it would be:

5, 6, 7, 8, 9, 10

所以，这个数应该是max-min+1。

i.e. 10 - 5 + 1 = 6

随机数将生成一个介于0-5之间的数字。

i.e. 0, 1, 2, 3, 4, 5

将最小值添加到随机数将产生：

5, 6, 7, 8, 9, 10

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

< /块引用>< /块引用>

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

这可以通过简单的陈述来实现：

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

下面是它的源代码

随机化

1
2
3
4
5
6
7
public class Randomizer
{
    public static int generate(int min,int max)
    {
        return min + (int)(Math.random() * ((max - min) + 1));
    }
}

它很干净很简单。

相关讨论

使用nextint(n)方法为最小值和最大值的差生成一个随机数，然后将最小值添加到结果中：

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

As of Java 7, you should no longer use Random. For most uses, the
random number generator of choice is now
ThreadLocalRandom.

For fork join pools and parallel
streams, use SplittableRandom.

Joshua Bloch。有效的Java语言。第三版。

从Java 8开始

对于fork-join池和并行流，与Random相比，SplittableRandom通常更快，具有更好的统计独立性和一致性。

在[0, 1_000]:范围内生成随机int。

1
int n = new SplittableRandom().nextInt(0, 1_001);

在[0, 1_000]:范围内生成随机的int[100]数组值。

1
int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

要返回随机值流：

1
IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
相关讨论

下面是一个有用的类，可以在一个范围内生成任意ints，其中包含/排除界限的任意组合：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
    }
}
1
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

这样一看这randomutils或从Apache Commons。 ＜／P >

相关讨论

滚动的骰子的情况下它将随机数之间(在0 1 6 6)： ＜／P >

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

这种方法可能便于使用：

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

1
2
3
4
5
6
7
8
9
10
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;
    }
}

此方法将从提供的最小值和最大值中返回一个随机数(因此生成的数字也可以是最小值或最大值)：

1
2
3
4
5
6
public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}
相关讨论

要生成"介于两个数字之间"的随机数，请使用以下代码：

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

这将为您提供一个介于1(含)和11(不含)之间的随机数，因此通过添加1初始化上界值。例如，如果要生成介于1到10之间的随机数，则用11而不是10初始化上界数。

只需使用随机类：

1
2
3
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
相关讨论

我发现这个例子生成随机数：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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);
  }
}

此类的示例运行：

1
2
3
4
5
6
7
8
9
10
11
12
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.
1
2
3
4
5
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);
}

当你需要很多的随机数，我不recommend的随机类的API。它有一个"小周期。尝试在梅森捻线机代替。有是一个Java的执行。 ＜／P >

您可以在Java 8中简洁地实现：

1
2
3
4
5
6
7
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);

另一种选择是使用ApacheCommons：

1
2
3
4
5
6
7
8
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);
    // ...
 }

下面是一个简单的示例，演示如何从闭合的[min, max]范围生成随机数，而min <= max is true范围生成随机数。

您可以将其重用为孔类中的字段，也可以将所有Random.class方法放在一个位置。

结果示例：

1
2
3
4
5
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

资料来源：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
    }
}
相关讨论

最好使用SecureRandom，而不仅仅是Random。

1
2
3
4
5
6
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;
}
相关讨论

1
2
3
4
5
private static Random random = new Random();    

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

或

1
2
3
4
public static int getRandomInt(Random random, int min, int max)
{
  return random.nextInt(max - min + 1) + min;
}
相关讨论

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

这是精细的工作。 ＜／P >

我用这个：

1
2
3
4
5
6
7
8
 /**
   * @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;
 }

如果需要，可以将其转换为整数。

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
    }
}

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

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

使用myrandomnumber(这将给您一个范围内的数字)。

你可以这样做：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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));
    }
}

使用Java 8的ItStand和Collections.shuffle的不同方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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中的等价物

1
2
3
4
5
6
import scala.util.Random

object RandomRange extends App{
  val x =  Random.shuffle(5 to 10)
    println(x)
}
相关讨论

我将简单地说明问题提供的解决方案有什么问题，以及为什么会出现错误。

解决方案1：

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

问题：RandomNum被分配的值大于最大值。

说明：假设我们的最小值是5，您的最大值是10。来自Math.random()的任何值大于0.6将使表达式的值为6或更大，加上5将使其大于10(最大值)。问题是，你将随机数乘以最大值(它生成的数字几乎和最大值一样大)，然后再加上最小值。除非最小值是1，否则是不正确的。如其他答案所述，您必须切换到

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

+1是因为Math.random()永远不会返回1.0。

解决方案2：

1
2
3
4
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)。用这种方法，做

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

也会返回所需的结果。

相关讨论

你可以使用

1
RandomStringUtils.randomNumeric(int count)

方法也是来自ApacheCommons的。

1
2
3
4
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
相关讨论

我只是用math.random()生成一个随机数，然后用一个大的数乘以它，比如10000。所以，我得到一个介于0到10000之间的数字，把这个数字叫做i。现在，如果我需要介于(x，y)之间的数字，请执行以下操作：

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

所以，所有的i都是x和y之间的数字。

要消除注释中指出的偏差，而不是用10000(或大数字)乘以(y-x)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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));
    }

}

您也可以使用

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

但是，这个类在多线程环境中的性能并不好。

相关讨论

在尝试1中进行以下更改应该可以完成此工作-

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

检查此项以获取工作代码。

我正在考虑使用以下方法将生成的随机数线性规格化为所需的范围。设x为随机数，设a和b为期望归一化数的最小和最大范围。

下面是一个非常简单的代码截图来测试线性映射产生的范围。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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);
}

这将生成范围(最小-最大)不重复的随机数字列表。

1
generateRandomListNoDuplicate(1000, 8000, 500);

添加此方法。

1
2
3
4
5
6
7
8
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);
    }
}

希望这对你有帮助。

相关讨论

这是一个简单的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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在内的范围。

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

1
public static int nextInt(int n)

从math.random()序列返回一个介于0(含)和指定值(不含)之间的伪随机、均匀分布的int值。

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

1
int random = RandomUtils.nextInt(1000000);

注：在randomutils中，有许多随机数生成方法

我已经创建了一个方法来获取给定范围内的唯一整数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
      * 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;
}

我认为这段代码可以适用。请尝试此操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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);
    }
}

下面是使用Random和ForEach的另一个示例

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

我的一个朋友今天在大学里问了我同样的问题(他的要求是生成一个介于1和-1之间的随机数)。所以我写了这个，到目前为止它在我的测试中运行良好。在理想情况下，有很多方法可以在给定的范围内生成随机数。试试这个：

功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
}

这样执行：

1
System.out.println( getRandomNumberBetween(1,-1));
相关讨论

下面的代码生成一个介于100000和900000之间的随机数。此代码将生成六位数的值。我用这段代码生成一个六位数的OTP。

使用import java.util.Random使用此随机方法。

1
2
3
4
5
6
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);

您可以使用Random类生成随机数，然后使用.nextint(maxnumber)生成随机数。maxnumber是生成随机数时希望达到的最大值。不过请记住，随机类给出的是从0到maxnumber-1的数字。

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

另一种方法是使用math.random()类，学校中的许多类都要求您使用它，因为它更高效，而且您不必声明新的随机对象。要使用math.random()获取随机数，请键入：

1
Math.random() * (max - min) + min;

假设您想要0-9之间的范围，0是最小值，9是最大值。下面的函数将打印0到9之间的任何内容。所有范围都是一样的。

1
2
3
4
5
6
7
8
9
10
11
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);
}
相关讨论

范围[最小值.最大值]中的随机数：

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

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

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

它有边缘包涵/排除。

尝试使用org.apache.commons.lang.RandomStringUtils类。是的，它有时会相邻地给出一个重复的数字，但它会给出5到15之间的值：

1
2
3
4
5
6
7
8
9
10
    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;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);

}

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

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

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

在A和B之间生成n个随机数的简单方法例如a=90，b=100，n=20

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

r.ints()返回IntStream并有几个有用的方法，请看一下它的API。

上面大多数建议都不考虑"溢出"，例如：min=integer.min_value，max=100。到目前为止，我采用的正确方法之一是：

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

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

相关讨论

使用Java 8流，

  • 传递初始容量-多少个数字
  • 传递随机绑定-从X传递到随机绑定
  • 是否排序通过真/假
  • 传递新的random()对象

nbsp；

1
2
3
4
5
6
7
8
9
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个随机界限生成数字。

下面是一个示例类，演示如何在特定范围内生成随机整数。将您想要的任何值作为最大值分配给变量"max"，并将您想要的任何值作为最小值分配给变量"min"。

1
2
3
4
5
6
7
8
9
10
11
12
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);
    }

}