我试图获得0到100之间的随机数。但是我希望它们是唯一的，而不是在序列中重复。例如，如果我得到5个数字，它们应该是82,12,53,64,32而不是82,12,53,12,32 我使用了它，但它在序列中生成相同的数字。
Random rand = new Random();
selected = rand.nextInt(100);
答案 0 :(得分：119)
这是一个简单的实现。这将打印1-10范围内的3个唯一随机数。
import java.util.ArrayList;
import java.util.Collections;
public class UniqueRandomNumbers {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i=1; i<11; i++) {
list.add(new Integer(i));
}
Collections.shuffle(list);
for (int i=0; i<3; i++) {
System.out.println(list.get(i));
}
}
}
正如Mark Byers在现在删除的答案中指出的那样，使用原始方法修复的第一部分是仅使用单个Random实例。
这就是导致数字相同的原因。 Random实例以当前时间（以毫秒为单位）播种。对于特定的种子值，，“随机”实例将返回完全相同的 伪随机数字序列。
答案 1 :(得分：42)
使用Java 8+，您可以使用Random的{{3}}方法获取ints个随机值，然后IntStream和distinct来减少流一些独特的随机值。
ThreadLocalRandom.current().ints(0, 100).distinct().limit(5).forEach(System.out::println);
Random还有一些方法可以创建LongStream和DoubleStream，如果您需要这些方法。
如果你想要一个随机顺序的范围内的所有（或大量）数字，将所有数字添加到列表中更有效，将其洗牌，并取第一个n，因为上面的例子目前通过生成所请求范围内的随机数并将它们传递给集合（类似于limit）来实现，这可能需要生成比传递到限制的数量多得多的数量，因为生成新唯一数字的概率会降低找到每一个。这是另一种方式的例子：
List<Integer> range = IntStream.range(0, 100).boxed()
.collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(range);
range.subList(0, 99).forEach(System.out::println);
答案 2 :(得分：18)
long数组创建一个易于清除的布尔数组，您可以在其中移动和屏蔽以访问各个位。）答案 3 :(得分：16)
在所有100个号码上使用Collections.shuffle()并选择前五个，如图here所示。
答案 4 :(得分：11)
我觉得这种方法值得一提。
private static final Random RANDOM = new Random();
/**
* Pick n numbers between 0 (inclusive) and k (inclusive)
* While there are very deterministic ways to do this,
* for large k and small n, this could be easier than creating
* an large array and sorting, i.e. k = 10,000
*/
public Set<Integer> pickRandom(int n, int k) {
final Set<Integer> picked = new HashSet<>();
while (picked.size() < n) {
picked.add(RANDOM.nextInt(k + 1));
}
return picked;
}
答案 5 :(得分：8)
我重新考虑了Anand的答案，不仅要使用Set的唯一属性，还要使用set.add()在集合添加失败时返回的布尔值false。
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class randomUniqueNumberGenerator {
public static final int SET_SIZE_REQUIRED = 10;
public static final int NUMBER_RANGE = 100;
public static void main(String[] args) {
Random random = new Random();
Set set = new HashSet<Integer>(SET_SIZE_REQUIRED);
while(set.size()< SET_SIZE_REQUIRED) {
while (set.add(random.nextInt(NUMBER_RANGE)) != true)
;
}
assert set.size() == SET_SIZE_REQUIRED;
System.out.println(set);
}
}
答案 6 :(得分：6)
我是这样做的。
Random random = new Random();
ArrayList<Integer> arrayList = new ArrayList<Integer>();
while (arrayList.size() < 6) { // how many numbers u need - it will 6
int a = random.nextInt(49)+1; // this will give numbers between 1 and 50.
if (!arrayList.contains(a)) {
arrayList.add(a);
}
}
答案 7 :(得分：4)
这将生成唯一的随机数................
import java.util.HashSet;
import java.util.Random;
public class RandomExample {
public static void main(String[] args) {
Random rand = new Random();
int e;
int i;
int g = 10;
HashSet<Integer> randomNumbers = new HashSet<Integer>();
for (i = 0; i < g; i++) {
e = rand.nextInt(20);
randomNumbers.add(e);
if (randomNumbers.size() <= 10) {
if (randomNumbers.size() == 10) {
g = 10;
}
g++;
randomNumbers.add(e);
}
}
System.out.println("Ten Unique random numbers from 1 to 20 are : " + randomNumbers);
}
}
答案 8 :(得分：2)
我是从另一个问题来到这里的，这个问题与这个问题重复（Generating unique random number in java）
在数组中存储1到100个数字。
生成1到100之间的随机数作为位置并返回数组[position-1]以获取值
在数组中使用数字后，将值标记为-1（无需维护另一个数组以检查此数字是否已被使用）
如果数组中的值为-1，则再次获取随机数以获取数组中的新位置。
答案 9 :(得分：2)
这样做的一个聪明方法是在模数中使用原始元素的指数。
例如，2是原始根mod 101，意味着2 mod 101的权力为您提供了一个非重复序列，它可以看到从1到100的每个数字：
2^0 mod 101 = 1
2^1 mod 101 = 2
2^2 mod 101 = 4
...
2^50 mod 101 = 100
2^51 mod 101 = 99
2^52 mod 101 = 97
...
2^100 mod 101 = 1
在Java代码中，您可以写：
void randInts() {
int num=1;
for (int ii=0; ii<101; ii++) {
System.out.println(num);
num= (num*2) % 101;
}
}
查找特定模数的原始根可能很棘手，但Maple的“primroot”函数将为您完成此任务。
答案 10 :(得分：1)
尽管这是一个旧线程，但是添加另一个选项可能不会造成损害。 （JDK 1.8 lambda函数似乎很容易实现）；
该问题可以分为以下步骤；
以下是带有一些说明的功能：
/**
* Provided an unsequenced / sequenced list of integers, the function returns unique random IDs as defined by the parameter
* @param numberToGenerate
* @param idList
* @return List of unique random integer values from the provided list
*/
private List<Integer> getUniqueRandomInts(List<Integer> idList, Integer numberToGenerate) {
List<Integer> generatedUniqueIds = new ArrayList<>();
Integer minId = idList.stream().mapToInt (v->v).min().orElseThrow(NoSuchElementException::new);
Integer maxId = idList.stream().mapToInt (v->v).max().orElseThrow(NoSuchElementException::new);
ThreadLocalRandom.current().ints(minId,maxId)
.filter(e->idList.contains(e))
.distinct()
.limit(numberToGenerate)
.forEach(generatedUniqueIds:: add);
return generatedUniqueIds;
}
因此，要为“ allIntegers”列表对象获取11个唯一的随机数，我们将调用类似的函数；
List<Integer> ids = getUniqueRandomInts(allIntegers,11);
该函数声明新的arrayList'generatedUniqueIds'，并在返回之前使用每个唯一的随机整数填充，直到所需的数字为止。
P.S。 ThreadLocalRandom类避免在并发线程的情况下使用公共种子值。
答案 11 :(得分：0)
试试这个
public class RandomValueGenerator {
/**
*
*/
private volatile List<Double> previousGenValues = new ArrayList<Double>();
public void init() {
previousGenValues.add(Double.valueOf(0));
}
public String getNextValue() {
Random random = new Random();
double nextValue=0;
while(previousGenValues.contains(Double.valueOf(nextValue))) {
nextValue = random.nextDouble();
}
previousGenValues.add(Double.valueOf(nextValue));
return String.valueOf(nextValue);
}
}
答案 12 :(得分：0)
从0到m-1中选择n个唯一的随机数。
int[] uniqueRand(int n, int m){
Random rand = new Random();
int[] r = new int[n];
int[] result = new int[n];
for(int i = 0; i < n; i++){
r[i] = rand.nextInt(m-i);
result[i] = r[i];
for(int j = i-1; j >= 0; j--){
if(result[i] >= r[j])
result[i]++;
}
}
return result;
}
想象一下包含0到m-1之间数字的列表。要选择第一个号码，我们只需使用rand.nextInt(m)即可。然后从列表中删除该号码。现在还有m-1个数字，所以我们称之为rand.nextInt(m-1)。我们得到的数字代表了列表中的位置。如果它小于第一个数字，则它是第二个数字，因为第一个数字之前的列表部分没有通过删除第一个数字而改变。如果位置大于或等于第一个数字，则第二个数字是位置+ 1。做一些进一步的推导，你可以得到这个算法。
该算法具有O（n ^ 2）复杂度。因此，从大型集合中生成少量唯一数字是有益的。虽然基于shuffle的算法至少需要O（m）才能进行随机播放。
同样基于shuffle的算法需要内存来存储每个可能的结果来进行shuffle，这个算法不需要。
答案 13 :(得分：0)
这与其他答案没什么不同，但最后我想要整数数组：
Integer[] indices = new Integer[n];
Arrays.setAll(indices, i -> i);
Collections.shuffle(Arrays.asList(indices));
return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();
答案 14 :(得分：0)
以下是我用来始终生成唯一编号的方法。随机函数生成数字并将其存储在文本文件中，然后下次在文件中检查它时比较它并生成新的唯一编号，因此这样总会有一个新的唯一编号。
$ pytest hmm.py
======================================================= test session starts ========================================================
platform linux -- Python 3.6.4, pytest-3.4.1, py-1.5.2, pluggy-0.6.0
rootdir: /home/lettuce/Dropbox/Python/Python_3, inifile:
plugins: hypothesis-3.46.0
collected 3 items
hmm.py ... [100%]
==================================================== 3 passed in 15.34 seconds =====================================================
答案 15 :(得分：0)
您可以使用布尔数组来填充true（如果取值），否则请按照以下给定的设置通过布尔数组导航以获取值
package study;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
Created By Sachin Rane on Jul 18, 2018
*/
public class UniqueRandomNumber {
static Boolean[] boolArray;
public static void main(String s[]){
List<Integer> integers = new ArrayList<>();
for (int i = 0; i < 10; i++) {
integers.add(i);
}
//get unique random numbers
boolArray = new Boolean[integers.size()+1];
Arrays.fill(boolArray, false);
for (int i = 0; i < 10; i++) {
System.out.print(getUniqueRandomNumber(integers) + " ");
}
}
private static int getUniqueRandomNumber(List<Integer> integers) {
int randNum =(int) (Math.random()*integers.size());
if(boolArray[randNum]){
while(boolArray[randNum]){
randNum++;
if(randNum>boolArray.length){
randNum=0;
}
}
boolArray[randNum]=true;
return randNum;
}else {
boolArray[randNum]=true;
return randNum;
}
}
}
答案 16 :(得分：0)
对于这个问题，我有简单的解决方案， 这样，我们可以轻松生成n个唯一的随机数， 任何人都可以用任何语言使用它都是合理的逻辑。
for(int i=0;i<4;i++)
{
rn[i]= GenerateRandomNumber();
for (int j=0;j<i;j++)
{
if (rn[i] == rn[j])
{
i--;
}
}
}
答案 17 :(得分：0)
您可以使用Collections类。
一个名为Collections的实用程序类提供了可以在诸如ArrayList之类的集合上执行的不同操作（例如，搜索元素，找到最大或最小元素，颠倒元素的顺序，等等）。它可以执行的动作之一是对元素进行洗牌。随机播放将随机将每个元素移动到列表中的其他位置。它通过使用Random对象来实现。这意味着它是确定性随机性，但是在大多数情况下都可以。
要随机播放ArrayList，请将Collections导入添加到程序顶部，然后使用Shuffle静态方法。它以要改组的ArrayList作为参数：
import java.util.Collections;
import java.util.ArrayList;
public class Lottery {
public static void main(String[] args) {
//define ArrayList to hold Integer objects
ArrayList numbers = new ArrayList();
for(int i = 0; i < 100; i++)
{
numbers.add(i+1);
}
Collections.shuffle(numbers);
System.out.println(numbers);
}
}
答案 18 :(得分：0)
这是最简单的方法，用于在范围内或从数组中生成唯一的随机值。
在此示例中，我将使用预定义的数组，但是您也可以使用此方法来生成随机数。首先，我们将创建一个示例数组以从中检索数据。
ArrayList<Integer> sampleList = new ArrayList<>();
sampleList.add(1);
sampleList.add(2);
sampleList.add(3);
sampleList.add(4);
sampleList.add(5);
sampleList.add(6);
sampleList.add(7);
sampleList.add(8);
现在从sampleList开始，我们将产生五个唯一的随机数。
int n;
randomList = new ArrayList<>();
for(int i=0;i<5;i++){
Random random = new Random();
n=random.nextInt(8); //Generate a random index between 0-7
if(!randomList.contains(sampleList.get(n)))
randomList.add(sampleList.get(n));
else
i--; //reiterating the step
}
从概念上讲这很简单。如果生成的随机值已经存在，那么我们将重复该步骤。这将一直持续到生成的所有值都是唯一的为止。
如果您认为此答案有用，则可以将其投票，因为与其他答案相比，它在概念上非常简单。
答案 19 :(得分：-1)
您可以在Java中生成介于0到n-1之间的n个唯一随机数
public static void RandomGenerate(int n)
{
Set<Integer> st=new HashSet<Integer>();
Random r=new Random();
while(st.size()<n)
{
st.add(r.nextInt(n));
}
}
答案 20 :(得分：-2)
检查
public class RandomNumbers {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 5;
int A[] = uniqueRandomArray(n);
for(int i = 0; i<n; i++){
System.out.println(A[i]);
}
}
public static int[] uniqueRandomArray(int n){
int [] A = new int[n];
for(int i = 0; i< A.length; ){
if(i == A.length){
break;
}
int b = (int)(Math.random() *n) + 1;
if(f(A,b) == false){
A[i++] = b;
}
}
return A;
}
public static boolean f(int[] A, int n){
for(int i=0; i<A.length; i++){
if(A[i] == n){
return true;
}
}
return false;
}
}