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

用途：

minValue + rn.nextInt(maxValue - minValue + 1)

在Java1.7或更高中，执行此操作的标准方法如下：

import java.util.concurrent.ThreadLocalRandom;
// nextInt is normally exclusive of the top value,// so add 1 to make it inclusiveint randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

这种方法的优点是不需要显式初始化java.util.随机实例，如果使用不当，这可能会导致混淆和错误。

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

Java1.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 inclusiveint randomNum = rand.nextInt((max - min) + 1) + min;
return randomNum;}

在实践中，java.util.随机类通常比java.lang.Math.random（）类更可取。

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

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

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

例如：#0或#1

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

或者看看Apache Commons中的随机Utils。

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

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

请注意，这种方法比nextInt方法更有偏见，效率更低，https://stackoverflow.com/a/738651/360211

实现这一点的一个标准模式是：

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

Java Math库函数Math.random（）在[0,1)范围内生成一个双精度值。请注意，此范围不包括1。

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

Math.random() * ( Max - Min )

这将返回范围[0,Max-Min)中的值，其中不包括“Max-Min”。

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

Math.random() * 5

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

现在您需要将此范围向上移动到您的目标范围。您可以通过添加Min值来执行此操作。

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

你现在将获得范围[Min,Max)的值。按照我们的例子，这意味着[5,10)：

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

但是，这仍然不包括Max，并且你得到了一个双精度值。为了获得包含的Max值，你需要向范围参数(Max - Min)添加1，然后通过转换为int来截断小数部分。这是通过以下方式完成的：

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

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

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

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将返回25，因此nextInt( i.length )将返回0-24范围内的数字。另一个选项是使用Math.Random，其工作方式相同。

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

为了更好地理解，请查看论坛帖子随机区间（archive.org）。

用途：

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

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

在掷骰子的情况下，它将是1到6之间的随机数（不是0到6），所以：

face = 1 + randomNumbers.nextInt(6);

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

这工作得很好。

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

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

一个万无一失的解决方案将为[Integer.MIN_VALUE，Integer.MAX_VALUE]中的任何min <= max返回正确的结果。考虑以下简单的实现：

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%或更高。

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

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

这是一个有用的类，可以在包含/排他边界的任意组合的范围内生成随机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;}}

我找到了这个例子生成随机数：

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

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 problemslong range = (long)aEnd - (long)aStart + 1;// compute a fraction of the range, 0 <= frac < rangelong 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 : 9Generated : 3Generated : 3Generated : 9Generated : 4Generated : 1Generated : 3Generated : 9Generated : 10Generated : 10Done.

使用这些方法可能很方便：

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

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

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

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

使用myR的随机数（这将给你一个范围内的数字）。

我只是使用Math.random（）生成一个随机数并将其乘以一个大数字，假设为10000。所以，我得到一个介于0到10,000之间的数字并将其称为i。现在，如果我需要介于（x， y）之间的数字，请执行以下操作：

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

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

要消除评论中指出的偏差，而不是将其乘以10000（或大数字），请将其乘以（y-x）。

我的一个朋友今天在大学里问我同样的问题（他的要求是生成一个介于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));

ThreadLocalRandom相当于多线程环境中的类java.util.Random。生成随机数是在每个线程本地进行的。因此，通过减少冲突，我们有更好的性能。

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

x，y-间隔例如（1,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;}}

它可以通过简单地执行语句来完成：

Randomizer.generate(0, 10); // Minimum of zero and maximum of ten

下面是它的源代码。

文件Randomizer.java

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

它只是干净和简单。

我认为此代码适用于它。请尝试此操作：

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

我想通过使用以下方法将生成的随机数线性归一化为所需的范围。设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);}

只需使用随机类：

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

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

解决方案1：

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

问题：随机数被分配值大于最大值的数字。

解释：假设我们的最小值是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%，因此您也不会得到预期的结果。

然而，这几乎是完美的。您只需要在JavadocnextInt（int n）下一篇文章中进一步查看即可。使用该方法，做

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

也会返回想要的结果。

您可以使用Random类生成随机数，然后使用. nextInt（maxNumber）生成随机数。maxNumber是您在生成随机数时想要的最大数字。请记住，Random类为您提供0到maxNumes-1的数字。

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

另一种方法是使用Math. Random（）类，学校的许多课程都要求你使用它，因为它更有效，你不必声明新的Random对象。要使用Math. Random（）获取随机数，你输入：

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

import java.util.Random;
public class RandomUtil {// Declare as class variable so that it is not re-seeded every callprivate 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 inclusivereturn random.nextInt((max - min) + 1) + min;}}

让我们举个例子。

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

将分钟值添加到随机数将产生：

5、6、7、8、9、10

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

在#09;java-8&#09;" rel="tag">java-8中，他们在#1类中引入了方法#0。

例如，如果您想在[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值执行此操作。希望有帮助！：）

这是一个简单的示例，展示了如何从封闭的[min, max]范围生成随机数，而min <= max is true

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

结果示例：

RandomUtils random = new RandomUtils();random.nextInt(0, 0); // returns 0random.nextInt(10, 10); // returns 10random.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;}}

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

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

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

查看更多关于#0的实现

最好使用安全随机而不是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;}

你可以这样做：

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

使用nextint（n）方法为min和max的差异生成一个随机数，然后将min数添加到结果中：

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

范围[min… max]的随机数：

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

这将生成随机数列表与范围（最小-最大）与没有重复。

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

希望这对你有帮助。

以前的大多数建议都没有考虑溢出。例如：min=Integer.MIN_VALUE，max=100。到目前为止，我的正确方法之一是：

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

你可以用

RandomStringUtils.randomNumeric(int count)

方法也来自Apache Commons。

使用Java8 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 ArrayListrange.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle  using the Collections Fisher-Yates shuffleCollections.shuffle(ls);System.out.println(ls);}}

Scala中的等价物

import scala.util.Random
object RandomRange extends App{val x =  Random.shuffle(5 to 10)println(x)}

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

/** 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 orderSet<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 checkgenerated.add(next);}return generated;}

使用Java8 Streams，

• 传递初始化容量-多少个数字
• 通过随机绑定-从x到随机绑定
• 为排序与否传递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-随机绑定生成数字。

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

public static int nextInt(int startInclusive, int endExclusive)

返回指定范围内的随机整数。

参数：

开始包含-指定的起始值

结束独家-指定的结束值

int random = RandomUtils.nextInt(999,1000000);

注意：在随机工具中有许多随机数生成方法

我用这个：

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

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

您可以在Java8中简明扼要地实现这一点：

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

这是简单的方法来做到这一点。

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在内的范围。

在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。

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

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

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。

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

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

它具有边缘包含/排除。

下面的代码生成一个在100,000到900,000之间的随机数。此代码将生成六位数值。我正在使用此代码生成一个六位数检察官办公室。

使用import java.util.Random来使用这个随机方法。

import java.util.Random;
// Six digits random number generation for OTPRandom rnd = new Random();long longregisterOTP = 100000 + rnd.nextInt(900000);System.out.println(longregisterOTP);

假设你想要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);}

从Java7开始，您不应该再使用Random。选择的随机数生成器现在是#0.

用于分叉连接池和并行流，使用#0。

约书亚·布洛赫。有效Java。第三版。

从8Java开始

对于分叉连接池和并行流，使用SplittableRandom，与Random相比，它通常更快，具有更好的统计独立性和一致性属性。

在范围[0, 1_000]:中生成一个随机的int

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

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

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

要返回随机值的Stream：

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

下面是另一个使用Random和for每个的例子

int firstNum = 20;//Inclusiveint lastNum = 50;//Exclusiveint streamSize = 10;Random num = new Random().ints(10, 20, 50).forEach(System.out::println);

import java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {generateDummySSNNumber();}

//831-33-6049public static void generateDummySSNNumber() {Random random = new Random();
int id1 = random.nextInt(1000);//3int id2 = random.nextInt(100);//2int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));}
}

您也可以使用

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

但是，此类在多线程环境中表现不佳。

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

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

检查这个以获取工作代码。

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随机用于一般用途。

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

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

你可以像下面这样做。

import java.util.Random;public class RandomTestClass {
public static void main(String[] args) {Random r = new Random();int max, min;Scanner scanner = new Scanner(System.in);System.out.println("Enter maximum value : ");max = scanner.nextInt();System.out.println("Enter minimum value : ");min = scanner.nextInt();int randomNum;randomNum = r.nextInt(max) + min;System.out.println("Random Number : " + randomNum);}
}

可以使用以下代码：

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

这是一个函数，它在定义的范围内正好返回一个整数随机数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

…或者更短的时间用于一次性生成随机数

new SplittableRandom().nextInt(lowerBoundIncluded, upperBoundIncluded + 1);

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

使用Apache Lang3 Commons

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

最小值100000到最大值999999

您可以使用以下方法来做到这一点：

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

为了避免重复已经说过多次的内容，我通过使用安全随机类来展示那些需要密码学上更强大的伪随机数生成器的人的替代方案，该类扩展了Random类。从来源可以阅读：

这个类提供了一个加密强随机数生成器（RNG）。一个密码强随机数最低限度地遵守使用FIPS中指定的统计随机数生成器测试140-2，密码模块的安全要求，第4.9.1节。此外，SecureRandom必须产生非确定性输出。因此，传递给SecureRandom对象的任何种子材料都必须是不可预测，并且所有SecureRandom输出序列必须是加密强，如RFC 1750中所述：随机性安全问题

调用者通过无参数获取SecureRandom实例构造函数或getInstance方法之一：

  SecureRandom random = new SecureRandom();

许多SecureRandom实现都是伪随机数生成器的形式（PRNG），这意味着他们使用确定性算法来产生来自真随机种子的伪随机序列。其他实现可能产生真正的随机数，还有一些可能使用组合这两种技术。

要在min和max值之间生成随机数，包括：

public static int generate(SecureRandom secureRandom, int min, int max) {return min + secureRandom.nextInt((max - min) + 1);}

对于给定的min（包括）和max（不包括）值：

return min + secureRandom.nextInt((max - min));

一个正在运行的代码示例：

public class Main {
public static int generate(SecureRandom secureRandom, int min, int max) {return min + secureRandom.nextInt((max - min) + 1);}
public static void main(String[] arg) {SecureRandom random = new SecureRandom();System.out.println(generate(random, 0, 2 ));}}

stackoverflow、Baeldung、geeksforgeeks等源提供Random和SecureRandom类之间的比较。

从Baeldung可以读到：

使用SecureRandom最常见的方法是生成int、long、浮点、双精度或布尔值：

int随机Int=secureRandom.nextInt（）；
secureRandom.nextLong（）；
secureRandom.nextFloat（）；
secureRandom.nextDouble（）；
secureRandom.nextBoolean（）；

为了生成int值，我们可以传递一个上限作为参数：

intsecureRandom.nextInt（upperBound）；

此外，我们可以为int、Double和long生成一个值流：

IntStreamsecureRandom.ints；

LongStream=secureRandom.longs（）；
DoubleStream=secureRandom.doubles（）；

对于所有流，我们可以显式设置流大小：

intStream intStream=secureRandom.ints//数据流大小

此类提供了其他几个选项（例如，选择底层随机数生成器），这些选项超出了本问题的范围。

Random rng = new Random();int min = 3;int max = 11;int upperBound = max - min + 1; // upper bound is exclusive, so +1int num = min + rng.nextInt(upperBound);System.out.println(num);

int randomNum = 5 + (int)(Math.random()*5);

范围5-10

Java17引入了#0接口，它提供了#1方法来获取范围内的随机整数：

// Returns a random int between minimum (inclusive) & maximum (exclusive)int randomInt = RandomGenerator.getDefault().nextInt(minimum, maximum);

除了用于Java17中添加的新的随机生成算法之外，该接口还被添加到现有的随机生成类（#0、#1、#2和#3）中。因此，截至17Java，这些类具有这种有界nextInt方法：

new Random().nextInt(minimum, maximum);new SecureRandom().nextInt(minimum, maximum);new SplittableRandom().nextInt(minimum, maximum);new ThreadLocalRandom().nextInt(minimum, maximum);

截至Java17，这个方法是Random和SecureRandom的新方法。在Java17之前，ThreadLocalRandom和SplittableRandom已经有了这个方法，尽管它不是由共享接口指定的。

如果你不想重新发明轮子，这里有一个单行的，简单的解决方案：

RandomStringUtils.randomNumeric(count); // Where count is the number of digits you want in the random number.

Apache Commons，例如组件朗中的，提供了许多选项来生成您想要的任何格式的随机数。

因为安卓问题重定向到这里，这就是静态编程语言的方式：

val r = (0..10).random() // A random integer between 0 and 10 inclusive

这适用于静态编程语言1.3及更高版本。请参阅这个答案。