Java 为每个数组值生成唯一的随机数

我有一个方法，它为这个方法中列出的每个数组值生成一个数字（1-10）。我希望整个数字集显示为一组唯一的数字。如何做到这一点

public static int generateNumbers(int[] lotteryNumbers) {

    Random randNum = new Random();

    lotteryNumbers[0] = randNum.nextInt(10);
    lotteryNumbers[1] = randNum.nextInt(10);
    lotteryNumbers[2] = randNum.nextInt(10);
    lotteryNumbers[3] = randNum.nextInt(10);
    lotteryNumbers[4] = randNum.nextInt(10);

    return lotteryNumbers[4];
}

---

一个简单的解决方案是生成一个由10位数字组成的列表，对该列表进行洗牌，然后得到前五个元素：

List<Integer> list = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
    list.add(i);
}
Collections.shuffle(list);
Integer[] lotteryNumbers = list.subList(0, 5).toArray(new Integer[10]);

---

一种简单的方法是在要“洗牌”的集合中随机挑选：

---

此方法生成范围为[0，N-1]的唯一数字的长度为N的序列

public static int[] generateNumbers(int length) {
    final int[] array = new int[length];
    for (int i = 0; i < length; ++i) {
        array[i] = i;
    }
    shuffle(array);
    return array;
}

• 由于（）的原因，该算法的时间复杂度为O（n）
• 此实现适用于数组（使用基元）而不是集合（使用在对象中封装基元类型int值的Integer类实例）——数组大小是否足够大很重要

---

这里有一种替代方法，它使用一个集合并填充它，直到它增长到所需的大小。它生成numbersToDraw不同的随机数，范围从min到max（包括在内）。它还保留了数字的绘制顺序（这就是LinkedHashSet的用途）

private static Set drawNumber（int-min、int-max、int-numbersToDraw）{
如果（最大值<最小值）{
抛出新的IllegalArgumentException（“最小值必须小于最大值”）；
}
如果（最大值<0 | |最小值<0）{
抛出新的IllegalArgumentException（“两个范围数都必须为正”）；
}
最终整数计数=最大-最小+1；
if（countOfNumbers

如果不要求数字是唯一的，可以在Java 8中使用：

final Random randomizer = new SecureRandom();

final List<Integer> numbersDrawn = IntStream
        .range(0, numbersToDraw)
        .mapToObj(i -> min + randomizer.nextInt(max - min + 1))
        .collect(Collectors.toList());

final Random randomizer=new SecureRandom（）；
最终列表编号Drawed=IntStream
.范围（0，numbersToDraw）
.mapToObj（i->min+randomizer.nextInt（max-min+1））
.collect（Collectors.toList（））；

如果您不要求数字是唯一的，但希望打印其不同的值（这是您最初的问题吗？）

final Random randomizer=new SecureRandom（）；
最终设置编号Drawed=IntStream
.范围（0，numbersToDraw）
.mapToObj（i->min+randomizer.nextInt（max-min+1））
.collect（收集器.toSet（））；

对于您的具体案例，还有一个备选方案：

final Set<Integer> distinctNumbers = Arrays
  .stream(lotteryNumbers)
  .distinct() // you can leave this as the set is distinct automatically
  .boxed()
  .collect(Collectors.toSet());

final Set distinctNumbers=数组
.stream（乐透号码）
.distinct（）//可以保留此选项，因为集合是自动独立的
.boxed（）
.collect（收集器.toSet（））；

你不应该使用random。重复@nikpon。random有什么问题？非常好fine@Dici我没听清你的要求。如果你有问题，请在问题部分提问。@nikpon你告诉他不要使用

随机

，但是这个类没有问题谢谢@Tunkai。但是有没有一种方法可以让我用随机数生成唯一的数字呢？因为我只允许使用随机，因为这是学校的作业。没有内置的方式。您可以在循环中使用Random生成一个int，直到之前没有找到您获得的数字。@N.Cre请看我的答案，它的算法基本上与

Collections.shuffle

相同，但不使用库方法。知道这一点很好，对你们的任务也有好处，但要记住，在现实生活中，Tunaki的答案更好。我不介意你投我的票：D

public static int[] generateNumbers(int length) {
    final int[] array = new int[length];
    for (int i = 0; i < length; ++i) {
        array[i] = i;
    }
    shuffle(array);
    return array;
}

public static void shuffle(final int[] array) {
    final Random random = new Random();
    for (int i = array.length - 1; i > 0; --i) {
        final int randomIdx = random.nextInt(i + 1);
        final int temp = array[i];
        array[i] = array[randomIdx];
        array[randomIdx] = temp;
    }
}

private static Set<Integer> drawNumbers(int min, int max, int numbersToDraw) {
    if (max < min) {
        throw new IllegalArgumentException("Minimum must be less than maximum.");
    }
    if (max < 0 || min < 0) {
        throw new IllegalArgumentException("Both range numbers must be positive.");
    }
    final int countOfNumbers = max - min + 1;
    if (countOfNumbers < numbersToDraw) {
        throw new IllegalArgumentException("Range is not big enough.");
    }
    final Random randomizer = new SecureRandom();
    final Set<Integer> numbersDrawn = new LinkedHashSet<>();
    while (numbersDrawn.size() < numbersToDraw) {
        final int randomNumber = min + randomizer.nextInt(countOfNumbers);
        numbersDrawn.add(randomNumber);
    }
    return numbersDrawn;
}

final Random randomizer = new SecureRandom();

final List<Integer> numbersDrawn = IntStream
        .range(0, numbersToDraw)
        .mapToObj(i -> min + randomizer.nextInt(max - min + 1))
        .collect(Collectors.toList());

final Random randomizer = new SecureRandom();

final Set<Integer> numbersDrawn = IntStream
        .range(0, numbersToDraw)
        .mapToObj(i -> min + randomizer.nextInt(max - min + 1))
        .collect(Collectors.toSet());

final Set<Integer> distinctNumbers = Arrays
  .stream(lotteryNumbers)
  .distinct() // you can leave this as the set is distinct automatically
  .boxed()
  .collect(Collectors.toSet());