Ограничение повторяющихся случайных чисел

Мое решение сохраняет результат в 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);
}
}

Поскольку вы ограничены 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);
}

И затем, когда вы назначаете случайное число:

int i = rand.nextInt(numbers.size());
myArray[i][j] = numbers.get(i);
numbers.remove(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);
}

И если вы хотите их проверить, просто просмотрите свою карту и вуаля. :)

Вы можете создать метод, чтобы проверить, существует ли сгенерированное число в массиве более 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;

    }
}

Надеюсь, это помогло вам, если у вас есть другие вопросы, не стесняйтесь спрашивать.

Я принимаю предложение pshemek (голосовать за): вместо ArrayList я использую Set, потому что он не может содержать повторяющиеся числа, и вам не нужно усиливать контроль.

Реализация: копия{правая, левая принадлежит пшемеку, я лишь расширил идею :)

public class Example {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int[] numbers = new int[11];
        int sum = 0;
        final int range = 10;
        final int noOfOccurances = 4;
        Arrays.fill(numbers, 0);
        Random generator = new Random();
        Set<Integer> numbersArray = new TreeSet<Integer>();
        while (sum != range * noOfOccurances) {
            int randomNumber = generator.nextInt(range) + 1;
            sum++;//correction for first comment
            numbersArray.add(randomNumber); // randomNumber will never be twice: a Set cointains ever one and only one instance of an determinated element
        }
        System.out.println(numbersArray);
    }

  }//end class

Вы можете написать свой собственный:

public static class CountedRandom {
    // My rng.
    Random rand = new Random();
    // Keeps track of the counts so far.
    Map<Integer, Integer> counts = new HashMap<Integer, Integer>();
    // The limit I must apply.
    final int limit;

    public CountedRandom(int limit) {
        this.limit = limit;
    }

    public int nextInt(int l) {
        int r;
        do {
            // Keep getting a new number until we hit one that has'n been overused.
            r = rand.nextInt(l);
        } while (count(r) >= limit);
        return r;
    }

    private int count(int r) {
        // How many times have we seen this one so far.
        Integer counted = counts.get(r);
        if ( counted == null ) {
            // Never!
            counted = new Integer(0);
        }
        // Remember the new value.
        counts.put(r, counted + 1);
        // Returns 0 first time around.
        return counted;
    }
}

public void test() {
    CountedRandom cr = new CountedRandom(4);
    for ( int i = 0; i < 50; i++ ) {
        System.out.print(cr.nextInt(4)+",");
    }
    System.out.println();
}

Обратите внимание, что это зависнет, если вы запросите слишком много чисел в слишком маленьком диапазоне (как у меня в моем тесте).

Отпечатки

2,0,1,2,1,1,3,3,0,3,0,2,2,0,1,3,

а потом зависает.