Manera eficiente de barajar objetos

Estoy escribiendo un programa para algún software de prueba. Tengo una clase de pregunta que contiene las ArrayLists para la pregunta, respuesta, opciones, marcas y marcas negativas. Algo como esto:

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

Quiero barajar todas las preguntas, pero para que las preguntas se barajen, todos los objetos deben barajarse. Hubiera abordado este problema de esta manera:

En primer lugar, no habría usado este diseño y no usaría String ArrayList<String>como tipo de variables de instancia, y luego habría usado el Collections.shufflemétodo para barajar objetos. Pero mi equipo insiste en este diseño.

Ahora, la clase de preguntas contiene ArrayLists crecientes a medida que se realiza la entrada a las preguntas. ¿Cómo barajar las preguntas ahora?

Su equipo sufre un problema común: la negación de objetos .

En lugar de una clase que contenga una sola pregunta con toda la información asociada, intente crear una clase llamada questionque contenga todas las preguntas en una sola instancia.

Esa es la manera equivocada de ella, y complica lo que intente hacer un montón ! Ordenar (y barajar) matrices paralelas (o listas) es un negocio desagradable y no hay una API común para ello, simplemente porque generalmente desea evitarlo .

Le sugiero que reestructure su código así:

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 esta manera, barajar su pregunta se vuelve trivial (usando Collections.shuffle()):

Collections.shuffle(questionList);

Usted no Haces otra lista / cola de índices y barajas eso. Luego, recorre los índices que conducen el orden "barajado" de sus otras colecciones.

Incluso fuera de su escenario con cosas divididas, la colección de pedidos por separado proporciona una serie de beneficios (paralelismo, velocidad al volver a colocar la colección original es costosa, etc.).

Estoy de acuerdo con las otras respuestas en que la solución correcta es usar un modelo de objeto adecuado.

Sin embargo, en realidad es bastante fácil mezclar varias listas de manera idéntica:

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 una clase Question2:

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

Luego, cree una función que asigne un questiona ArrayList<Question2>, use Collection.Shufflepara ese resultado y cree una segunda función para ArrayList<Question2>volver a asignar question.

Luego, vaya a su equipo e intente convencerlos de que usar un en ArrayList<Question2>lugar de questionmejoraría mucho su código, ya que les ahorraría muchas de esas conversiones innecesarias.

Mi respuesta ingenua e incorrecta original :

Simplemente cree (al menos) nnúmeros aleatorios e intercambie el elemento n con el elemento ien un ciclo for para cada lista que tenga.

En pseudocódigo:

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

}

Actualizar:

Gracias por the_lotus por señalar el artículo de horror de codificación. Ahora me siento mucho más inteligente :-) De todos modos, Jeff Atwood también muestra cómo hacerlo bien, utilizando el algoritmo de 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 principal diferencia aquí es que cada elemento se intercambia solo una vez.

Y aunque las otras respuestas explican correctamente que su modelo de objetos es defectuoso, es posible que no esté en la posición de cambiarlo. Entonces, el algoritmo de Fisher-Yates resolvería su problema sin cambiar su modelo de datos.