Effiziente Methode zum Mischen von Objekten

Ich schreibe ein Programm für eine Quizsoftware. Ich habe eine Frageklasse, die die ArrayLists für die Frage, die Antwort, die Optionen, die Marken und die negativen Marken enthält. Etwas wie das:

class question
{
    private ArrayList<Integer> index_list;
    private ArrayList<String> question_list;        
    private ArrayList<String> answer_list;      
    private ArrayList<String> opt1_list;        
    private ArrayList<String> opt2_list;    
}

Ich möchte alle Fragen mischen, aber damit Fragen gemischt werden, müssen alle Objekte gemischt werden. Ich hätte dieses Problem folgendermaßen angegangen:

Zunächst hätte ich dieses Design nicht verwendet und String nicht ArrayList<String>als Instanzvariablen verwendet und dann die Collections.shuffleMethode zum Mischen von Objekten verwendet. Aber mein Team besteht auf diesem Entwurf.

Jetzt enthält die Fragenklasse zunehmende ArrayLists, wenn der Eintrag zu den Fragen vorgenommen wird. Wie mische ich die Fragen jetzt?

Ihr Team leidet unter einem allgemeinen Problem: der Verweigerung von Objekten .

Anstelle einer Klasse, die eine einzelne Frage mit allen damit verbundenen Informationen enthält, versuchen Sie, eine Klasse mit dem Namen zu erstellen question, die alle Fragen in einer einzelnen Instanz enthält.

Das ist der falsche Weg, und es erschwert, was Sie versuchen, viel zu tun ! Parallele Arrays (oder Listen) zu sortieren (und zu mischen) ist eine unangenehme Angelegenheit und es gibt keine gemeinsame API dafür, einfach weil Sie es normalerweise überhaupt vermeiden wollen .

Ich schlage vor, Sie strukturieren Ihren Code folgendermaßen um:

class Question
{
    private Integer index;
    private String question;        
    private String answer;      
    private String opt1;        
    private String opt2;    
}

// somewhere else
List<Question> questionList = new ArrayList<Question>();

Auf diese Weise wird das Mischen Ihrer Frage trivial (mit Collections.shuffle()):

Collections.shuffle(questionList);

Das tust du nicht. Sie erstellen eine weitere Liste / Warteschlange von Indizes und mischen diese. Dann durchlaufen Sie die Indizes, die die Reihenfolge Ihrer anderen Sammlungen bestimmen.

Auch außerhalb Ihres Szenarios mit getrennten Bereichen bietet die separate Bestellsammlung eine Reihe von Vorteilen (Parallelität, Geschwindigkeit beim Wiedereinsetzen der ursprünglichen Sammlung sind kostspielig usw.).

Ich stimme den anderen Antworten zu, dass die richtige Lösung darin besteht, ein geeignetes Objektmodell zu verwenden.

Es ist jedoch recht einfach, mehrere Listen auf dieselbe Weise zu mischen:

Random rnd = new Random();
long seed = rnd.nextLong();

rnd.setSeed(seed);
Collections.shuffle(index_list, rnd);
rnd.setSeed(seed);
Collections.shuffle(question_list, rnd);
rnd.setSeed(seed);
Collections.shuffle(answer_list, rnd);
...

Erstelle eine Klasse Question2:

class Question2
{
    public Integer index_list;
    public String question_list;        
    public String answer_list;      
    public String opt1_list;        
    public String opt2_list;    
}

Erstellen Sie dann eine Funktion, die ein questionto zuordnet ArrayList<Question2>, verwenden Sie Collection.Shufflefür dieses Ergebnis und erstellen Sie eine zweite Funktion für die Zuordnung ArrayList<Question2>zurück zu question.

Gehen Sie anschließend zu Ihrem Team und versuchen Sie, sie davon zu überzeugen, dass die Verwendung von a ArrayList<Question2>statt questionden Code erheblich verbessern würde, da sie dadurch eine Menge unnötiger Konvertierungen einsparen würden.

Meine ursprüngliche naive und falsche Antwort:

Erstellen Sie einfach (mindestens) nZufallszahlen und tauschen Sie Artikel n mit Artikeln iin einer for-Schleife für jede Liste aus, die Sie haben.

Im Pseudocode:

for (in i = 0; i < question_list.length(); i++) {
  int random = randomNumber(0, questions_list.length()-1);
  question_list.switchItems(i, random);
  answer_list.switchItems(i, random);
  opt1_list.switchItems(i, random);
  opt2_list.switchItems(i, random);

}

Aktualisieren:

Vielen Dank für den Hinweis auf den Horror-Artikel. Ich fühle mich jetzt viel schlauer :-) Wie auch immer, Jeff Atwood zeigt auch, wie man es richtig macht, indem er den Fisher-Yates-Algorithmus verwendet :

for (int i = question_list.Length - 1; i > 0; i--){
  int n = rand.Next(i + 1); //assuming rand.Next(x) returns values between 0 and x-1
  question_list.switchItems(i, n);
  answer_list.switchItems(i, n);
  opt1_list.switchItems(i, n);
  opt2_list.switchItems(i, n);
}

Der Hauptunterschied besteht darin, dass jedes Element nur einmal ausgetauscht wird.

Und während die anderen Antworten korrekt erklären, dass Ihr Objektmodell fehlerhaft ist, sind Sie möglicherweise nicht in der Lage, es zu ändern. Der Fisher-Yates-Algorithmus würde also Ihr Problem lösen, ohne Ihr Datenmodell zu ändern.