Modo efficiente per mescolare gli oggetti

Sto scrivendo un programma per alcuni software di quiz. Ho una classe di domande che contiene gli ArrayList per domande, risposte, opzioni, segni e segni negativi. Qualcosa come questo:

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

Voglio mescolare tutte le domande, ma affinché le domande vengano mescolate, tutti gli oggetti devono essere mescolati. Avrei affrontato questo problema in questo modo:

Prima di tutto, non avrei usato questo design e non avrei usato String ArrayList<String>come tipo di variabile di istanza, e quindi avrei usato il Collections.shufflemetodo per mescolare gli oggetti. Ma il mio team insiste su questo design.

Ora, la classe di domande contiene liste di array in aumento man mano che si inserisce la domanda. Come mescolare le domande ora?

La tua squadra soffre di un problema comune: la negazione degli oggetti .

Invece di una classe che contiene una singola domanda con tutte le informazioni ad essa associate, si tenta di creare una classe chiamata questionche contiene tutte le domande in una singola istanza.

Questo è il modo sbagliato di farlo e complica ciò che cerchi di fare molto ! L'ordinamento (e lo shuffle) di matrici parallele (o Liste) è un brutto affare e non esiste un'API comune, semplicemente perché di solito si desidera evitarlo affatto .

Ti suggerisco di ristrutturare il tuo codice in questo modo:

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

In questo modo, mescolare la tua domanda diventa banale (usando Collections.shuffle()):

Collections.shuffle(questionList);

Non Fai un altro elenco / coda di indici e lo mescoli. Quindi ripeti gli indici che guidano l'ordine "mischiato" delle altre tue raccolte.

Anche al di fuori del tuo scenario con elementi divisi, la raccolta ordini separata offre una serie di vantaggi (il parallelismo, la velocità quando il ripristino della raccolta originale è costoso, ecc.).

Concordo con le altre risposte sul fatto che la soluzione corretta è utilizzare un modello di oggetto adeguato.

Tuttavia, in realtà è abbastanza facile mescolare più liste in modo identico:

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

Crea un corso Question2:

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

Quindi creare una funzione mappando questiona ArrayList<Question2>, usare Collection.Shuffleper quel risultato e creare una seconda funzione per mappare di ArrayList<Question2>nuovo a question.

Successivamente, vai al tuo team e prova a convincerli che l'uso di un ArrayList<Question2>invece di questionmigliorerebbe molto il loro codice, dal momento che li salverebbe molte di quelle conversioni inutili.

La mia risposta ingenua e sbagliata originale :

Basta creare (almeno) nnumeri casuali e scambiare l'oggetto n con l'elemento iin un ciclo for per ogni elenco che hai.

In pseudo codice:

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

}

Aggiornare:

Grazie per the_lotus per aver segnalato l'articolo horror sulla codifica. Mi sento molto più intelligente ora :-) Comunque Jeff Atwood mostra anche come farlo nel modo giusto, usando l' algoritmo 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);
}

La differenza principale qui è che ogni elemento viene scambiato una sola volta.

E mentre le altre risposte spiegano correttamente che il tuo modello a oggetti è difettoso, potresti non essere in grado di cambiarlo. Quindi l'algoritmo Fisher-Yates risolverebbe il tuo problema senza cambiare il tuo modello di dati.