Java 限制重复随机数

我只是想知道如何限制随机数出现的次数。我已经生成了1到10的随机数，并希望限制每个数字出现4次

myArray[i][j] = rand.nextInt(11);

for (int i=0; i < myArray.length; i++) {
   for (int j=0; j < myArray[i].length; j++) {
       myArray[i][j] = rand.nextInt(11);
       System.out.print(" " + myArray[i][j]);

myArray[i][j]=rand.nextInt（11）；
for（int i=0；i

---

上面的代码创建了随机数。只想限制它们。

由于您被限制为10*4=40个数字，您可以使用列表并随机索引：

List<Integer> numbers = new ArrayList<Integer>();
for (int i = 1; i < 11; ++i) {
   for (int j = 0; j < 4; ++j) 
      numbers.add(i);
}

---

这假设您的二维数据包含的数字不会超过40个

，因为您被限制为10*4=40个数字，您可以使用列表并随机化索引：

List<Integer> numbers = new ArrayList<Integer>();
for (int i = 1; i < 11; ++i) {
   for (int j = 0; j < 4; ++j) 
      numbers.add(i);
}

---

这假设您的二维数据包含的数字不会超过40个

如何将生成的整数的计数存储在数组、映射或任何东西中

Map<Integer, Integer> randomCounts = new HashMap<Integer, Integer>(); 
... your for loops
myArray[i][j] = rand.nextInt(11);
if (randomCounts.containsKey(myArray[i][j])) { 
   randomCounts.put(myArray[i][j],randomCounts.get(myArray[i][j])+1);
} else {
   randomCounts.put(myArray[i][j],1);
}

Map randomCounts=new HashMap（）；
…您的for循环
myArray[i][j]=rand.nextInt（11）；
if（randomCounts.containsKey（myArray[i][j]）{
randomCounts.put（myArray[i][j]，randomCounts.get（myArray[i][j]）+1）；
}否则{
randomCounts.put（myArray[i][j]，1）；
}

---

如果你想检查它们，只需遍历你的映射，瞧。：

把生成的int的计数存储在数组、映射或任何东西中怎么样

Map<Integer, Integer> randomCounts = new HashMap<Integer, Integer>(); 
... your for loops
myArray[i][j] = rand.nextInt(11);
if (randomCounts.containsKey(myArray[i][j])) { 
   randomCounts.put(myArray[i][j],randomCounts.get(myArray[i][j])+1);
} else {
   randomCounts.put(myArray[i][j],1);
}

Map randomCounts=new HashMap（）；
…您的for循环
myArray[i][j]=rand.nextInt（11）；
if（randomCounts.containsKey（myArray[i][j]）{
randomCounts.put（myArray[i][j]，randomCounts.get（myArray[i][j]）+1）；
}否则{
randomCounts.put（myArray[i][j]，1）；
}

---

如果您想检查它们，只需在地图中迭代，然后瞧。

我的解决方案将结果存储在arrayList中：

public class Example {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    final int range = 10;
    int[] numbers = new int[range + 1];
    int sum = 0;
    final int noOfOccurances = 4;
    final int size = range * noOfOccurances;
    Arrays.fill(numbers, 0);
    Random generator = new Random();
    List<Integer> numbersArray = new ArrayList<>();
    while (sum != size) {
        int randomNumber = generator.nextInt(range) + 1;
        if (numbers[randomNumber] != noOfOccurances) {
            numbers[randomNumber]++;
            sum++;
            numbersArray.add(randomNumber);
        }
    }
    System.out.println(numbersArray);
}
}

公共类示例{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
最终整数范围=10；
int[]数字=新的int[范围+1]；
整数和=0；
最终精度=4；
最终整数大小=范围*精度；
数组。填充（数字，0）；
随机生成器=新随机（）；
List numbersArray=new ArrayList（）；
while（总和=大小）{
int randomNumber=生成器.nextInt（范围）+1；
if（数字[随机数字]！=noOfOccurances）{
数字[随机数字]+；
sum++；
numbersArray.add（随机数）；
}
}
System.out.println（数字阵列）；
}
}

我的解决方案将结果存储在arrayList中：

public class Example {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    final int range = 10;
    int[] numbers = new int[range + 1];
    int sum = 0;
    final int noOfOccurances = 4;
    final int size = range * noOfOccurances;
    Arrays.fill(numbers, 0);
    Random generator = new Random();
    List<Integer> numbersArray = new ArrayList<>();
    while (sum != size) {
        int randomNumber = generator.nextInt(range) + 1;
        if (numbers[randomNumber] != noOfOccurances) {
            numbers[randomNumber]++;
            sum++;
            numbersArray.add(randomNumber);
        }
    }
    System.out.println(numbersArray);
}
}

公共类示例{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
最终整数范围=10；
int[]数字=新的int[范围+1]；
整数和=0；
最终精度=4；
最终整数大小=范围*精度；
数组。填充（数字，0）；
随机生成器=新随机（）；
List numbersArray=new ArrayList（）；
while（总和=大小）{
int randomNumber=生成器.nextInt（范围）+1；
if（数字[随机数字]！=noOfOccurances）{
数字[随机数字]+；
sum++；
numbersArray.add（随机数）；
}
}
System.out.println（数字阵列）；
}
}

您可以创建一种方法来检查生成的数字在数组中是否存在超过4次，如果存在，则创建一个新的随机数。它应该如下所示：

import java.util.Random;

public class rndNumberGenerator {

    public static void main (String[] args) {

        int[][] myArray = new int[2][5];
        Random rand = new Random();
        int randomNumber;

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {

                do {
                    randomNumber = rand.nextInt(11);
                } while(overMax(myArray, randomNumber) == true);

                myArray[i][j] = randomNumber;

                System.out.print(" " + myArray[i][j]);

            }
        }

    }

    public static boolean overMax(int[][] array, int number) {

        int max = 4;
        int count = 0;

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {

                if (array[i][j] == number) {
                    count++;
                }

            }
        }

        if (count >= max)
            return true;
        else
            return false;

    }
}

import java.util.Random；
公共类rndNumberGenerator{
公共静态void main（字符串[]args）{
int[]myArray=newint[2][5]；
Random rand=新的Random（）；
整数随机数；
对于（int i=0；i<2；i++）{
对于（int j=0；j<5；j++）{
做{
randomNumber=rand.nextInt（11）；
}while（overMax（myArray，randomNumber）==true）；
myArray[i][j]=随机数；
系统输出打印（“+myArray[i][j]）；
}
}
}
公共静态布尔overMax（int[][]数组，int编号）{
int max=4；
整数计数=0；
对于（int i=0；i<2；i++）{
对于（int j=0；j<5；j++）{
if（数组[i][j]==个数）{
计数++；
}
}
}
如果（计数>=最大值）
返回true；
其他的
返回false；
}
}

---

希望这对您有所帮助，如果您还有其他问题，请随时提问。

您可以创建一种方法，检查生成的数字在数组中是否存在超过4次，如果存在，则创建一个新的随机数。它应该如下所示：

import java.util.Random;

public class rndNumberGenerator {

    public static void main (String[] args) {

        int[][] myArray = new int[2][5];
        Random rand = new Random();
        int randomNumber;

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {

                do {
                    randomNumber = rand.nextInt(11);
                } while(overMax(myArray, randomNumber) == true);

                myArray[i][j] = randomNumber;

                System.out.print(" " + myArray[i][j]);

            }
        }

    }

    public static boolean overMax(int[][] array, int number) {

        int max = 4;
        int count = 0;

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {

                if (array[i][j] == number) {
                    count++;
                }

            }
        }

        if (count >= max)
            return true;
        else
            return false;

    }
}

import java.util.Random；
公共类rndNumberGenerator{
公共静态void main（字符串[]args）{
int[]myArray=newint[2][5]；
Random rand=新的Random（）；
整数随机数；
对于（int i=0；i<2；i++）{
对于（int j=0；j<5；j++）{
做{
randomNumber=rand.nextInt（11）；
}while（overMax（myArray，randomNumber）==true）；
myArray[i][j]=随机数；
系统输出打印（“+myArray[i][j]）；
}
}
}
公共静态布尔overMax（int[][]数组，int编号）{
int max=4；
整数计数=0；
对于（int i=0；i<2；i++）{
对于（int j=0；j<5；j++）{
if（数组[i][j]==个数）{
计数++；
}
}
}
如果（计数>=最大值）
返回true；
其他的
返回false；
}
}

---

希望这对您有所帮助，如果您有任何其他问题，请随意提问。

我接受了pshemek的建议（投票赞成）：我使用

数组列表，而不是
集合，因为它不能包含重复的数字，而且您不必特别注意控制

实现：副本{right，left}是pshemek的，我只是扩展了这个想法：）

pu