Java 如果每个数字都在一个数字范围内，如何生成随机数？

我试图找出如何在数组中生成和存储10个随机数，其中数字是两位数，每个位数都在0-7之间。例如，10、23、35、77都可以，但不是1、78、89、99。而且，我想确保所有的数字都是唯一的。这是我到目前为止所做的

import java.util.Random;
public class RandomNum{
      public static void main(String[] args){
            Random rand=new Random();
            int[] randomFirstDigit=new int[10];
             int[] randomSecondDigit=new int[10];

             for(int i=0;i<10;i++){
                 randomFirstDigit[i]=rand.nextInt(7-1+1)+1;
             }
             for(int i=0;i<10;i++){
                 randomSecondDigit[i]=rand.nextInt(7-1+1)+0;
             }
             int[] randomArr=new int[10];
             for(int i=0;i<10;i++){
             randomArr[i]=(randomFirstDigit[i]*10)+randomSecondDigit[i];
             }
             for(int i=0;i<=randomArr.length;i++){
                 System.out.println(randomArr[i]);
             }
      }
}

import java.util.Random；
公共类随机数{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
int[]randomFirstDigit=新的int[10]；
int[]随机第二位数=新的int[10]；
对于（int i=0；i请再次循环数组，并检查其是否已存在。这不是最佳解决方案，因为有些代码是冗余的，但可以为您提供一些有关如何处理它的提示

import java.util.Random;
public class RandomNum{
      public static void main(String[] args){
            Random rand=new Random();
            int[] randomFirstDigit=new int[10];
             int[] randomSecondDigit=new int[10];

             for(int i=0;i<10;i++){
                int gen = rand.nextInt(7-1+1)+1;
                Boolean flag = false;
                 for(int j=0; j < 10; j++)
                  if(randomFirstDigit[j] == gen) 
                   flag = true
                if(!flag) randomFirstDigit[i] = gen;
             }

             for(int i=0;i<10;i++){
                int gen = rand.nextInt(7-1+1)+0;
                Boolean flag = false;
                 for(int j=0; j < 10; j++)
                  if(randomSecondDigit[j] == gen) 
                   flag = true;
                if(!flag) randomSecondDigit[i] = gen;
             }

             int[] randomArr=new int[10];
             for(int i=0;i<10;i++){
               randomArr[i]=(randomFirstDigit[i]*10)+randomSecondDigit[i];
             }
             for(int i=0;i<=randomArr.length;i++){
                 System.out.println(randomArr[i]);
             }
      }
}

import java.util.Random；
公共类随机数{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
int[]randomFirstDigit=新的int[10]；
int[]随机第二位数=新的int[10]；
对于（int i=0；i请再次循环数组，并检查其是否已存在。这不是最佳解决方案，因为有些代码是冗余的，但可以为您提供一些有关如何处理它的提示

import java.util.Random;
public class RandomNum{
      public static void main(String[] args){
            Random rand=new Random();
            int[] randomFirstDigit=new int[10];
             int[] randomSecondDigit=new int[10];

             for(int i=0;i<10;i++){
                int gen = rand.nextInt(7-1+1)+1;
                Boolean flag = false;
                 for(int j=0; j < 10; j++)
                  if(randomFirstDigit[j] == gen) 
                   flag = true
                if(!flag) randomFirstDigit[i] = gen;
             }

             for(int i=0;i<10;i++){
                int gen = rand.nextInt(7-1+1)+0;
                Boolean flag = false;
                 for(int j=0; j < 10; j++)
                  if(randomSecondDigit[j] == gen) 
                   flag = true;
                if(!flag) randomSecondDigit[i] = gen;
             }

             int[] randomArr=new int[10];
             for(int i=0;i<10;i++){
               randomArr[i]=(randomFirstDigit[i]*10)+randomSecondDigit[i];
             }
             for(int i=0;i<=randomArr.length;i++){
                 System.out.println(randomArr[i]);
             }
      }
}

import java.util.Random；
公共类随机数{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
int[]randomFirstDigit=新的int[10]；
int[]随机第二位数=新的int[10]；
对于（int i=0；i而言，更简单且计算成本更低的解决方案是一次生成一个数字，然后将其附加到字符串中。之后可以将其转换为整数

为了精确地生成10个唯一的数字，我们可以将生成的每个数字添加到a，其中每个元素都必须是唯一的。我们可以继续此操作，直到HashSet有10个元素

import java.util.Random;
import java.util.Set;
import java.util.HashSet;

public class TwoDigitGenerator {

    public static void main(String[] args) {

        // Generate 10 unique random numbers with desired properties.
        Set<Integer> usedNumbers = new HashSet<>();
        while (usedNumbers.size() < 10)
            usedNumbers.add(randomNumber());

        // Convert the set of numbers to an Integer array.
        Integer[] numbers = usedNumbers.toArray(new Integer[usedNumbers.size()]);

        for (Integer number : numbers)
            System.out.println(number);
    }

    public static int randomNumber() {
        Random random = new Random();
        String number = "";
        number += 1 + random.nextInt(7); // Generate first digit between 1 and 7 inclusively
        number += random.nextInt(8); // Generate second digit between 0 and 7 inclusively
        return Integer.parseInt(number);
    }

}

import java.util.Random；
导入java.util.Set；
导入java.util.HashSet；
公共类TwoDigitGenerator{
公共静态void main（字符串[]args）{
//生成10个具有所需属性的唯一随机数。
Set usedNumbers=new HashSet（）；
while（usedNumbers.size（）<10）
usedNumbers.add（randomNumber（））；
//将数字集转换为整数数组。
整数[]number=usedNumbers.toArray（新整数[usedNumbers.size（））；
for（整数：数字）
系统输出打印项次（编号）；
}
公共静态整数随机数（）{
随机=新随机（）；
字符串编号=”；
number+=1+random.nextInt（7）；//生成1和7之间的第一个数字
number+=random.nextInt（8）；//生成0和7之间的第二个数字
返回整数.parseInt（number）；
}
}
一种更简单、计算成本更低的解决方案是一次生成一个数字，然后将其附加到字符串中。之后可以将其转换为整数

为了精确地生成10个唯一的数字，我们可以将生成的每个数字添加到a，其中每个元素都必须是唯一的。我们可以继续此操作，直到HashSet有10个元素

import java.util.Random;
import java.util.Set;
import java.util.HashSet;

public class TwoDigitGenerator {

    public static void main(String[] args) {

        // Generate 10 unique random numbers with desired properties.
        Set<Integer> usedNumbers = new HashSet<>();
        while (usedNumbers.size() < 10)
            usedNumbers.add(randomNumber());

        // Convert the set of numbers to an Integer array.
        Integer[] numbers = usedNumbers.toArray(new Integer[usedNumbers.size()]);

        for (Integer number : numbers)
            System.out.println(number);
    }

    public static int randomNumber() {
        Random random = new Random();
        String number = "";
        number += 1 + random.nextInt(7); // Generate first digit between 1 and 7 inclusively
        number += random.nextInt(8); // Generate second digit between 0 and 7 inclusively
        return Integer.parseInt(number);
    }

}

import java.util.Random；
导入java.util.Set；
导入java.util.HashSet；
公共类TwoDigitGenerator{
公共静态void main（字符串[]args）{
//生成10个具有所需属性的唯一随机数。
Set usedNumbers=new HashSet（）；
while（usedNumbers.size（）<10）
usedNumbers.add（randomNumber（））；
//将数字集转换为整数数组。
整数[]number=usedNumbers.toArray（新整数[usedNumbers.size（））；
for（整数：数字）
系统输出打印项次（编号）；
}
公共静态整数随机数（）{
随机=新随机（）；
字符串编号=”；
number+=1+random.nextInt（7）；//生成1和7之间的第一个数字
number+=random.nextInt（8）；//生成0和7之间的第二个数字
返回整数.parseInt（number）；
}
}
因此，可能的数字列表是
[10,11,12，…，17,20，…，76,77]
并且它的大小是
7*8
。我们需要的是10个不同的随机数，代表该列表上的索引，然后我们可以使用
i->（i/8+1）*10+（i%8）
将它们映射到实际的数字

下面是一个使用
ThreadLocalRandom.ints
的非常简单的解决方案：

int[] array = ThreadLocalRandom.current()
        .ints(0, 7 * 8)
        .distinct()
        .limit(10)
        .map(i -> (i / 8 + 1) * 10 + (i % 8))
        .toArray();

因此，可能的数字列表是
[10，11，12，…，17，20，…，76，77]
，它的大小是
7*8
。我们需要的是10个不同的随机数，代表该列表上的索引，然后我们可以使用
i->（i/8+1）*10+（i%8）
将它们映射到实际的数字

下面是一个使用
ThreadLocalRandom.ints
的非常简单的解决方案：

int[] array = ThreadLocalRandom.current()
        .ints(0, 7 * 8)
        .distinct()
        .limit(10)
        .map(i -> (i / 8 + 1) * 10 + (i % 8))
        .toArray();

问题是这不是C++。标签被删除了。我假设这些下注是来自那些阅读标题而没有阅读问题细节的人。这个问题比“生成一个随机数”更重要。我建议一个编辑标题。问题是这不是C++。标签被删除了。我假设这些下注是来自阅读标题的人，而不是阅读问题的细节。这个问题比“生成一个随机数”更重要。。我将建议编辑标题。此代码未编译。它在第13行缺少分号，并在我第一次运行它时引发了ArrayIndexOutOfBoundException。它还生成了许多不允许的0。此代码未编译。它在第13行缺少分号，并在我第一次运行它时引发了ArrayIndexOutOfBoundExceptiont、 它还生成了大量不允许的0。是否保证不存在重复？@Jon是的。我已经解决了这个问题。是否保证不存在重复？@Jon是的。我有地址