Un moyen efficace de mélanger les objets

J'écris un programme pour un logiciel de quiz. J'ai une classe de questions contenant les ArrayLists pour la question, la réponse, les options, les notes et les notes négatives. Quelque chose comme ça:

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

Je veux mélanger toutes les questions, mais pour que les questions soient mélangées, tous les objets doivent être mélangés. J'aurais abordé ce problème de cette façon:

Tout d'abord, je n'aurais pas utilisé cette conception et utilisé String ne pas ArrayList<String>taper comme variables d'instance, et j'aurais ensuite utilisé la Collections.shuffleméthode pour mélanger les objets. Mais mon équipe insiste sur cette conception.

Maintenant, la classe de questions contient des listes de tableaux croissantes à mesure que l'entrée des questions est effectuée. Comment mélanger les questions maintenant?

Votre équipe souffre d'un problème commun: le déni d'objet .

Au lieu d'une classe qui contient une seule question avec toutes les informations qui lui sont associées, vous essayez de créer une classe appelée questionqui contient toutes les questions dans une seule instance.

C'est la mauvaise façon de procéder et cela complique ce que vous essayez de faire beaucoup ! Trier (et mélanger) des tableaux (ou des listes) parallèles est une tâche délicate et il n'y a pas d'API commune pour cela, simplement parce que vous voulez généralement l'éviter du tout .

Je vous suggère de restructurer votre code comme ceci:

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

De cette façon, mélanger votre question devient trivial (en utilisant Collections.shuffle()):

Collections.shuffle(questionList);

Non. Vous créez une autre liste / file d'attente d'index et mélangez cela. Ensuite, vous parcourez les index qui déterminent l'ordre "mélangé" de vos autres collections.

Même en dehors de votre scénario avec des éléments séparés, la collecte de commande séparée offre un certain nombre d'avantages (le parallélisme, la vitesse lors de la réinstallation de la collection d'origine est coûteux, etc.).

Je suis d'accord avec les autres réponses que la bonne solution consiste à utiliser un modèle d'objet approprié.

Cependant, il est en fait assez facile de mélanger plusieurs listes de manière identique:

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

Créer une classe Question2 :

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

Créez ensuite une fonction mappant a questionà ArrayList<Question2>, utilisezCollection.Shuffle pour ce résultat et créez une deuxième fonction pour mapper ArrayList<Question2>vers question.

Ensuite, allez voir votre équipe et essayez de les convaincre que l'utilisation d'un ArrayList<Question2>au lieu de questionaméliorerait beaucoup leur code, car cela leur permettrait d'économiser beaucoup de conversions inutiles.

Ma réponse naïve et fausse d'origine :

Créez simplement (au moins) ndes nombres aléatoires et échangez l'élément n avec l'élément idans une boucle for pour chaque liste que vous avez.

En pseudo code:

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

}

Mise à jour:

Merci pour the_lotus d'avoir signalé l'article d'horreur sur le codage. Je me sens beaucoup plus intelligent maintenant :-) Quoi qu'il en soit, Jeff Atwood montre également comment le faire correctement, en utilisant l' algorithme 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 principale différence ici est que chaque élément n'est échangé qu'une seule fois.

Et tandis que les autres réponses expliquent correctement que votre modèle d'objet est défectueux, vous pourriez ne pas être en mesure de le changer. Ainsi, l'algorithme Fisher-Yates résoudrait votre problème sans changer votre modèle de données.