Java 生成随机数数组并替换重复项

我正在生成一个1-54范围内的6整数数组（类似于乐透号码）。但是，当尝试检测重复项时，我的代码不会执行。如果我的条件逻辑捕捉到一个副本，我尝试通过简单地打印“Wehavefindareplicate”进行调试。当然，它不会打印所需的输出：

18-33-39-41-41-45

我想检测重复项，以便生成另一个随机数，该随机数不等于发现的重复项。我不想仅仅为了得到另一个数字而增加/减少复制值，我想实际生成另一个1到54之间的值，它不等于复制值

这是我的密码：

public class Main {

    public static void main(String[] args) {

        Random rand = new Random();
        int[] luckyArray = new int[6];

        //build array
        for (int i = 0; i < luckyArray.length; i++) {

            int luckyNumber = rand.nextInt(54) + 1;
            luckyArray[i] = luckyNumber;
        }
        //detect duplicates in the array
        for (int i = 0; i < luckyArray.length; i++) {
            if (i > 0 && luckyArray[i] == luckyArray[i - 1]) {
                System.out.print("WE HAVE FOUND A DUPLICATE!");
                /* while (luckyArray[i - 1] == luckyArray[i]) {
                    luckyArray[i] = rand.nextInt(54) + 1;
                }*/
            }
        }
        //sort the array before printing
        Arrays.sort(luckyArray);
        for (int t = 0; t < luckyArray.length; t++) {

            if (t != 5) {
                System.out.print(luckyArray[t] + "-");
            } else System.out.print(luckyArray[t]);
        }
    }
}

公共类主{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
int[]luckyArray=新int[6]；
//构建阵列
for（int i=0；i0&&luckyArray[i]==luckyArray[i-1]）{
System.out.print（“我们发现了一个副本！”）；
/*while（luckyArray[i-1]==luckyArray[i]）{
luckyArray[i]=rand.nextInt（54）+1；
}*/
}
}
//打印前对阵列进行排序
排序（luckyArray）；
for（int t=0；t

我希望将当前索引

[I]

与其以前的

[I-1]

进行比较，如果它们相等，则为当前索引生成一个新值

提前谢谢

我（个人）将依靠

集合的属性来确保您根本不保留重复项-您甚至不必检查重复项：

    Random rand = new Random();
    int numNumsToGenerate = 6;
    Set<Integer> luckySet = new HashSet<Integer>();

    //build set
    while (luckySet.size() < numNumsToGenerate) {
        luckySet.add(rand.nextInt(54) + 1);
    }

我（个人）将依靠
集合的属性来确保您根本不保留重复项-您甚至不必检查重复项：

    Random rand = new Random();
    int numNumsToGenerate = 6;
    Set<Integer> luckySet = new HashSet<Integer>();

    //build set
    while (luckySet.size() < numNumsToGenerate) {
        luckySet.add(rand.nextInt(54) + 1);
    }

使用Java 8：

List<Integer> luckys = 
    IntStream.rangeClosed(1, 54)
             .boxed()
             .collect(collectingAndThen(toList(), l -> {
                 Collections.shuffle(l);
                 return l;
             }))
             .stream()
             .limit(6)
             .collect(toList())

List luckys=
IntStream.rangeClosed（1,54）
.boxed（）
.collect（收集）然后（toList（），l->{
收藏。洗牌（l）；
返回l；
}))
.stream（）
.限额（6）
.collect（toList（））
使用Java 8：

List<Integer> luckys = 
    IntStream.rangeClosed(1, 54)
             .boxed()
             .collect(collectingAndThen(toList(), l -> {
                 Collections.shuffle(l);
                 return l;
             }))
             .stream()
             .limit(6)
             .collect(toList())

List luckys=
IntStream.rangeClosed（1,54）
.boxed（）
.collect（收集）然后（toList（），l->{
收藏。洗牌（l）；
返回l；
}))
.stream（）
.限额（6）
.collect（toList（））
在检查重复项之前，向上移动“排序”。通过这种方式，您可以确保副本始终位于彼此相邻的位置，并且您只需要检查相邻的副本

此处显示检测重复项的代码：

package luckynumber;

import java.util.Arrays;
import java.util.Random;

public class Main {

    public static void main(String[] args) {

        Random rand = new Random();
        int[] luckyArray = new int[6];

        // build array
        for (int i = 0; i < luckyArray.length; i++) {

            int luckyNumber = rand.nextInt(54) + 1;
            luckyArray[i] = luckyNumber;
        }
        // sort the array before detecting duplicates
        Arrays.sort(luckyArray);
        // detect duplicates in the array
        for (int i = 0; i < luckyArray.length; i++) {
            if (i > 0 && luckyArray[i] == luckyArray[i - 1]) {
                System.out.print("WE HAVE FOUND A DUPLICATE!");
                /* while (luckyArray[i - 1] == luckyArray[i]) { luckyArray[i] =
                 * rand.nextInt(54) + 1; } */
            }
        }
        for (int t = 0; t < luckyArray.length; t++) {

            if (t != 5) {
                System.out.print(luckyArray[t] + "-");
            } else
                System.out.print(luckyArray[t]);
        }
    }
}

包幸运号；
导入java.util.array；
导入java.util.Random；
公共班机{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
int[]luckyArray=新int[6]；
//构建阵列
for（int i=0；i0&&luckyArray[i]==luckyArray[i-1]）{
System.out.print（“我们发现了一个副本！”）；
/*而（luckyArray[i-1]==luckyArray[i]）{luckyArray[i]=
*兰德·奈斯汀（54）+1；}*/
}
}
for（int t=0；t

当您现在发现重复项并更改数组项时，请确保重新排序并重新检查整个数组。剩下的步骤留给读者作为练习。；-）

顺便说一句：使用Set将使代码更简单。
在检查重复项之前，向上移动“排序”。通过这种方式，您可以确保副本始终位于彼此相邻的位置，并且您只需要检查相邻的副本

此处显示检测重复项的代码：

package luckynumber;

import java.util.Arrays;
import java.util.Random;

public class Main {

    public static void main(String[] args) {

        Random rand = new Random();
        int[] luckyArray = new int[6];

        // build array
        for (int i = 0; i < luckyArray.length; i++) {

            int luckyNumber = rand.nextInt(54) + 1;
            luckyArray[i] = luckyNumber;
        }
        // sort the array before detecting duplicates
        Arrays.sort(luckyArray);
        // detect duplicates in the array
        for (int i = 0; i < luckyArray.length; i++) {
            if (i > 0 && luckyArray[i] == luckyArray[i - 1]) {
                System.out.print("WE HAVE FOUND A DUPLICATE!");
                /* while (luckyArray[i - 1] == luckyArray[i]) { luckyArray[i] =
                 * rand.nextInt(54) + 1; } */
            }
        }
        for (int t = 0; t < luckyArray.length; t++) {

            if (t != 5) {
                System.out.print(luckyArray[t] + "-");
            } else
                System.out.print(luckyArray[t]);
        }
    }
}

包幸运号；
导入java.util.array；
导入java.util.Random；
公共班机{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
int[]luckyArray=新int[6]；
//构建阵列
for（int i=0；i0&&luckyArray[i]==luckyArray[i-1]）{
System.out.print（“我们发现了一个副本！”）；
/*而（luckyArray[i-1]==luckyArray[i]）{luckyArray[i]=
*兰德·奈斯汀（54）+1；}*/
}
}
for（int t=0；t

当您现在发现重复项并更改数组项时，请确保重新排序并重新检查整个数组。剩下的步骤留给读者作为练习。；-）

顺便说一句：使用Set将使代码更简单。
如果Set是