Генерация пары случайных чисел в java без повторения пары

Question

Я хочу сгенерировать пару случайных чисел без повторения пары. Как я могу реализовать его в java?

Answer 1

Random r = new Random(); 
int x, y; 

do { 
    x = r.nextInt(); 
    y = r.nextInt(); 
} while (x == y); 

Answer 2

Нам необходимо отслеживать пары, которые уже сгенерированы. Следующий код должен делать:

Random random = new Random(); 
Map<Integer, Integer> generated = new HashMap<Integer, Integer>(); 
int x,y; 
do{ 
    x = random.nextInt(); 
    y = random.nextInt(); 
    if(!generated.containsKey(x) || generated.get(x) != y){ 
     generated.put(x, y); 
     break; 
    } 
}while(true); 

Answer 3

В случае, если вам нужно больше, чем 2 числа, этот метод может быть более эффективным:

List<Integer> integers = IntStream.range(1, 10) 
     .boxed() 
     .collect(Collectors.toList()); 

Collections.shuffle(integers); 

System.out.println(integers.get(0)); 
System.out.println(integers.get(1)); 

Answer 4

Насколько я понимаю ваш вопрос, который вы хотите, чтобы генерировать случайные пары чисел не повторяя их. Для этого нам прежде всего нужен класс, содержащий значения, так как это пара чисел, которые я буду называть кортежем.

public class Tuple { 
    private Integer first; 
    private Integer second; 

    public Tuple(int first, int second) { 
     this.first = first; 
     this.second = second; 
    } 

    public int getFirst() { 
     return first; 
    } 

    public int getSecond() { 
     return second; 
    } 

    @Override 
    public boolean equals(Object o) { 
     if (this == o) return true; 
     if (o == null || getClass() != o.getClass()) return false; 

     Tuple tuple = (Tuple) o; 
     return first.equals(tuple.first) && second.equals(tuple.second); 
    } 

    @Override 
    public int hashCode() { 
     int result = first.hashCode(); 
     result = 31 * result + second.hashCode(); 
     return result; 
    } 
} 

Тогда нам нужен класс генератора для хранения максимально возможного целого числа, которое может отображаться в паре. Обратите внимание, что это число ограничивает количество пар, поскольку у вас могут быть кортежи, которые содержат 1 ... n чисел как первое число, и для каждого из них снова 1 ... n чисел как второй вы можете вернуть n * n кортежей максимум !

public class RandomTuples { 
    private final int highestInt; 
    private final Set<Tuple> usedTuples = new HashSet<>(); 

    public RandomTuples(int highestInt) { 
     this.highestInt = highestInt; 
    } 

    public Tuple nextTuple() { 
     if (usedTuples.size() >= highestInt*highestInt) { 
      throw new RuntimeException("All possible tuples were used. " + 
        "Use a higher param when instantiating RandomTuples for more!"); 
     } 

     Random rnd = new Random(); 

     Tuple tuple = Stream 
       .generate(() -> new Tuple(rnd.nextInt(highestInt), rnd.nextInt(highestInt))) 
       .filter(filterTuple -> !usedTuples.contains(filterTuple)) 
       .limit(1).findFirst().get(); 
     usedTuples.add(tuple); 
     return tuple; 
    } 
} 

Исключение имеет решающее значение здесь, поскольку поток будет работать в тупике в противном случае. Это generate новых кортежи пытаются получить по крайней мере, одну соответствующей записи (limit(1)), тогда как filter будет удалить эту запись, создавая бесконечный цикл ...

Затем вы должны создать экземпляр класса RandomTouples и вызвать метод генераторного, чтобы получить новый кортеж. При использовании высоких чисел это может работать с довольно плохими характеристиками, поскольку оно должно пытаться использовать возможные комбинации, пока не найдет тот, который еще не использовался.

public class RandomTuplesExample { 

    public static void main(String[] args) { 

     RandomTuples randomTuples = new RandomTuples(10); 
     for (int i = 0; i < 100; i++) { 
      Tuple tuple = randomTuples.nextTuple(); 
      System.out.println("(" + tuple.getFirst() + ", " + tuple.getSecond() + ")"); 
     } 
    } 
}