Skuteczny sposób tasowania obiektów

Piszę program do jakiegoś oprogramowania quizowego. Mam klasę pytań zawierającą ArrayLists dla pytania, odpowiedzi, opcji, znaków i znaków ujemnych. Coś takiego:

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;    
}

Chcę tasować wszystkie pytania, ale aby pytania były tasowane, wszystkie obiekty muszą być tasowane. Podszedłbym do tego problemu w następujący sposób:

Po pierwsze, nie użyłbym tego projektu i nie używałbym String ArrayList<String>jako zmiennych instancji, a następnie użyłbym Collections.shufflemetody do losowego przesyłania obiektów. Ale mój zespół nalega na ten projekt.

Teraz klasa pytań zawiera coraz większą liczbę ArrayLists w miarę wprowadzania danych do pytań. Jak teraz tasować pytania?

Twój zespół ma typowy problem: odmowa obiektu .

Zamiast klasy, która zawiera jedno pytanie ze wszystkimi powiązanymi z nią informacjami, próbujesz utworzyć klasę o nazwie, questionktóra zawiera wszystkie pytania w jednym wystąpieniu.

To zły sposób, aby to zrobić i komplikuje to, co próbujesz zrobić dużo ! Sortowanie (i tasowanie) równoległych tablic (lub list) to paskudna sprawa i nie ma dla nich wspólnego API, po prostu dlatego, że zwykle w ogóle chcesz tego uniknąć .

Sugeruję restrukturyzację kodu w następujący sposób:

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>();

W ten sposób tasowanie pytania staje się banalne (używanie Collections.shuffle()):

Collections.shuffle(questionList);

Ty nie. Tworzysz kolejną listę / kolejkę indeksów i przetasujesz ją. Następnie iterujesz w dół indeksy, które określają kolejność „przetasowania” innych kolekcji.

Nawet poza scenariuszem, w którym rzeczy są rozdzielone, oddzielna kolekcja zamawiania zapewnia szereg korzyści (równoległość, szybkość ponownego umieszczania oryginalnej kolekcji jest kosztowna itp.).

Zgadzam się z innymi odpowiedziami, że poprawnym rozwiązaniem jest użycie odpowiedniego modelu obiektowego.

W rzeczywistości jednak dość łatwo jest tasować wiele list w identyczny sposób:

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);
...

Utwórz klasę Question2 :

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

Następnie utwórz funkcję odwzorowującą questionna ArrayList<Question2>, użyjCollection.Shuffle dla tego wyniku i utwórz drugą funkcję do odwzorowania z ArrayList<Question2>powrotem question.

Następnie idź do swojego zespołu i spróbuj przekonać ich, że użycie ArrayList<Question2>zamiast zamiast questionznacznie poprawiłoby ich kod, ponieważ zaoszczędziłoby im to wiele niepotrzebnych konwersji.

Moja oryginalna naiwna i zła odpowiedź:

Po prostu utwórz (przynajmniej) nliczby losowe i zamień przedmiot na n przedmioti w pętli for dla każdej listy, którą masz.

W pseudokodzie:

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);

}

Aktualizacja:

Dzięki za the_lotus za wskazanie artykułu o horrorze kodowania. Teraz czuję się znacznie mądrzejszy :-) W każdym razie Jeff Atwood pokazuje również, jak to zrobić dobrze, używając algorytmu Fisher-Yates :

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);
}

Główną różnicą jest to, że każdy element jest zamieniany tylko raz.

I podczas gdy inne odpowiedzi poprawnie wyjaśniają, że twój model obiektowy jest wadliwy, możesz nie być w pozycji, aby go zmienić. Tak więc algorytm Fisher-Yates rozwiązałby twój problem bez zmiany modelu danych.