Stackoverflow錯誤，同時從一系列數字中生成一組2個非重複的隨機數

Question

下面是我用來從一系列數字生成一個隨機數的兩種方法。這是一個小型數學測驗的一部分。問題的數量可以達到50個問題。唯一的條款是數字應該是不重複的，即如果列表中存在5x6，我不能在列表中包含6x5。

我面臨的問題是下面的代碼拋出stackoverflow錯誤。我試圖在單獨的線程中運行它，但我無法讓它工作。

在第一種方法中使用的for循環是我用來檢查數字是否已經存在的循環。

public QuestionsV1 generateQuestionsArray(int level, int range) { 
generateRandomNumbers(level, range); 
    for (QuestionsV1 questions : questionsList) { 
     if (questionsList != null && ((first_number == questions.getFirst_number() && second_number == questions.getSecond_number()) 
       || (first_number == questions.getSecond_number() && 
       second_number == questions.getFirst_number()))) { 
      generateQuestionsArray(level, range); 
      break; 
     } 
    } 
    Log.d("ArrayList---", first_number + " " + second_number); 
    QuestionsV1 questions = new QuestionsV1(); 
    questions.setFirst_number(first_number); 
    questions.setSecond_number(second_number); 
    questions.setOperator("x"); 
    questions.setCorrect_answer(first_number * second_number); 
    return questions; 
} 


public void generateRandomNumbers(int level, int range) { 
    Random rand1 = new Random(); 
    Random rand2 = new Random(); 
    if (range == 0) { 
     first_number = rand1.nextInt(3 - 1 + 1) + 1; 
    } else if (range == 1) { 
     first_number = rand1.nextInt(6 - 4 + 1) + 4; 
    } else if (range == 2) { 
     first_number = rand1.nextInt(10 - 7 + 1) + 7; 
    } 
    switch (level) { 
     case 1: 
      second_number = rand2.nextInt(6 - 2 + 1) + 2; 
      break; 
     case 2: 
      second_number = rand2.nextInt(12 - 7 + 1) + 7; 
      break; 
     case 3: 
      second_number = rand2.nextInt(20 - 13 + 1) + 13; 
      break; 

    } 

下面是我得到的錯誤。

Fatal Exception: java.lang.StackOverflowError: stack size 2MB 
    at java.util.concurrent.atomic.AtomicLong.<init>(AtomicLong.java:61) 
    at java.util.Random.<init>(Random.java:137) 
    at java.util.Random.<init>(Random.java:105) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:80) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbers(Multiply.java:106) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateQuestionsArray(Multiply.java:39) 
    at com.leapscale.scimat.t4e.Builders.Multiply.generateRandomNumbersHard(Multiply.java:74) 
    at com.leapscale.scimat.t4e.Builders.Multiply.calculateNoOfQuestionsForLevels(Multiply.java:141) 
    at com.leapscale.scimat.t4e.Builders.Multiply.getList(Multiply.java:146) 
    at com.leapscale.scimat.t4e.Levels.Levels_Fragment$QuestionBuilder$1.run(Levels_Fragment.java:185) 
    at java.lang.Thread.run(Thread.java:761) 

Answer 1

而不是使用遞歸調用使用while循環，以保持發電，直到創建一個非重複值。一些與此類似：

import java.util.ArrayList; 
import java.util.List; 
import java.util.Random; 

public class App { 
    private static final int QUESTION_COUNT = 25; 
    private static final int RANGE = 10; 
    private static final Random RAND = new Random(); 

    public static void main(String[] args) { 
     App app = new App(); 
     app.generateAndDisplayQuestions(); 
    } 

    private void generateAndDisplayQuestions() { 
     List<QuestionV1> questions = new ArrayList<>(); 
     for (int q = 0; q < QUESTION_COUNT; q++) { 
      while(true) { 
       QuestionV1 question = getNextRandomQuestion(); 
       if (!questions.contains(question)) { 
        questions.add(question); 
        break; 
       } 
       System.out.println("found a duplicate - trying again..."); 
      } 

      System.out.println("Question " + (q + 1) + ": first = " + questions.get(q).getFirst() + " : second = " + questions.get(q).getSecond()); 
     } 
    } 

    private QuestionV1 getNextRandomQuestion() { 
     return new QuestionV1(RAND.nextInt(RANGE), RAND.nextInt(RANGE)); 
    } 

    private class QuestionV1 { 
     private int first; 
     private int second; 

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

     @Override 
     public boolean equals(Object o) { 
      QuestionV1 other = (QuestionV1)o; 
      return (this.first == other.first && this.second == other.second) || (this.first == other.second && this.second == other.first); 
     } 

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

     public int getFirst() { 
      return first; 
     } 

     public int getSecond() { 
      return second; 
     } 

    } 

} 

這並不是說，如果RANGE低，QUESTION_COUNT高，那麼這將導致無限循環，因爲所有可能的組合將被使用。