Maneira eficiente de embaralhar objetos

Estou escrevendo um programa para algum software de teste. Eu tenho uma classe de pergunta contendo os ArrayLists para a pergunta, resposta, opções, marcas e marcas negativas. Algo assim:

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

Quero embaralhar todas as perguntas, mas, para que as perguntas sejam embaralhadas, todos os objetos precisam ser embaralhados. Eu teria abordado esse problema desta maneira:

Primeiro de tudo, eu não teria usado esse design e String não ArrayList<String>digitado como variáveis ​​de instância e, em seguida, teria usado o Collections.shufflemétodo para embaralhar objetos. Mas minha equipe insiste nesse design.

Agora, a classe de perguntas contém ArrayLists crescentes à medida que a entrada para as perguntas é feita. Como embaralhar as perguntas agora?

Sua equipe sofre de um problema comum: negação de objeto .

Em vez de uma classe que contém uma única pergunta com todas as informações associadas, você tenta criar uma classe chamada questionque contém todas as perguntas em uma única instância.

Esse é o caminho errado, e complica o que você tenta fazer muito ! Classificar (e embaralhar) matrizes paralelas (ou Listas) é um negócio desagradável e não existe uma API comum para isso, simplesmente porque você geralmente deseja evitá-lo .

Eu sugiro que você reestruture seu código assim:

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

Dessa forma, embaralhar sua pergunta se torna trivial (usando Collections.shuffle()):

Collections.shuffle(questionList);

Você não Você cria outra lista / fila de índices e embaralha isso. Em seguida, você itera os índices que controlam a ordem "aleatória" de suas outras coleções.

Mesmo fora do seu cenário, com as coisas divididas, a coleção de pedidos separada oferece vários benefícios (paralelismo, velocidade ao recolocar a coleção original é caro, etc.).

Concordo com as outras respostas de que a solução correta é usar um modelo de objeto adequado.

No entanto, é realmente muito fácil embaralhar várias listas da mesma maneira:

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

Crie uma classe Question2:

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

Em seguida, crie uma função mapeada questionpara ArrayList<Question2>, use Collection.Shufflepara esse resultado e crie uma segunda função para mapear ArrayList<Question2>novamente question.

Depois, vá para sua equipe e tente convencê-los de que usar um em ArrayList<Question2>vez de questionmelhoraria muito o código deles, pois economizaria muitas conversões desnecessárias.

Minha resposta ingênua e errada original :

Basta criar (pelo menos) nnúmeros aleatórios e trocar itens n com itens iem um loop for para cada lista que você possui.

No pseudo có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);

}

Atualizar:

Obrigado pelo the_lotus por apontar o artigo sobre horror de codificação. Sinto-me muito mais esperto agora :-) De qualquer forma, Jeff Atwood também mostra como fazê-lo corretamente, usando o 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);
}

A principal diferença aqui é que cada elemento é trocado apenas uma vez.

E enquanto as outras respostas explicam corretamente que seu modelo de objeto é defeituoso, você pode não estar na posição de alterá-lo. Portanto, o algoritmo Fisher-Yates resolveria seu problema sem alterar seu modelo de dados.