Cách hiệu quả để xáo trộn các đối tượng

Tôi đang viết một chương trình cho một số phần mềm đố vui. Tôi có một lớp câu hỏi chứa ArrayLists cho câu hỏi, câu trả lời, tùy chọn, nhãn hiệu và dấu âm. Một cái gì đó như thế này:

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

Tôi muốn xáo trộn tất cả các câu hỏi, nhưng để các câu hỏi được xáo trộn, tất cả các đối tượng cần được xáo trộn. Tôi đã có thể tiếp cận vấn đề này theo cách này:

Trước hết, tôi sẽ không sử dụng thiết kế này và sử dụng Chuỗi không ArrayList<String>gõ làm biến Collections.shuffleđối tượng và sau đó sẽ sử dụng phương thức để xáo trộn các đối tượng. Nhưng nhóm của tôi nhấn mạnh vào thiết kế này.

Bây giờ, lớp câu hỏi đang chứa ArrayLists ngày càng tăng khi mục nhập cho các câu hỏi được thực hiện. Làm thế nào để xáo trộn các câu hỏi bây giờ?

Nhóm của bạn bị một vấn đề phổ biến: từ chối đối tượng .

Thay vì một lớp chứa một câu hỏi duy nhất với tất cả thông tin liên quan đến nó, bạn cố gắng tạo một lớp có tên questionchứa tất cả các câu hỏi trong một trường hợp duy nhất.

Đó là cách sai lầm để làm điều đó, và nó làm phức tạp những gì bạn cố gắng làm rất nhiều ! Sắp xếp (và xáo trộn) các mảng song song (hoặc Danh sách) là một công việc khó chịu và không có API chung cho nó, đơn giản vì bạn thường muốn tránh nó .

Tôi đề nghị bạn cấu trúc lại mã của bạn như thế này:

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

Bằng cách này, xáo trộn câu hỏi của bạn trở nên tầm thường (sử dụng Collections.shuffle()):

Collections.shuffle(questionList);

Bạn không. Bạn tạo một danh sách / hàng đợi các chỉ mục và xáo trộn đó. Sau đó, bạn lặp lại các chỉ mục điều khiển thứ tự "xáo trộn" của các bộ sưu tập khác của bạn.

Ngay cả bên ngoài kịch bản của bạn với những thứ tách ra, bộ sưu tập đặt hàng riêng biệt cung cấp một số lợi ích (song song, tốc độ khi gắn lại bộ sưu tập ban đầu là tốn kém, v.v.).

Tôi đồng ý với các câu trả lời khác rằng giải pháp chính xác là sử dụng mô hình đối tượng phù hợp.

Tuy nhiên, thực sự khá dễ dàng để xáo trộn nhiều danh sách theo cách giống hệt nhau:

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

Tạo một lớp Question2:

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

Sau đó tạo một hàm ánh xạ a questionđến ArrayList<Question2>, sử dụng Collection.Shufflecho kết quả đó và tạo một hàm thứ hai để ánh xạ ArrayList<Question2>trở lại question.

Sau đó, hãy đến nhóm của bạn và cố gắng thuyết phục họ rằng sử dụng ArrayList<Question2>thay vì questionsẽ cải thiện mã của họ rất nhiều, vì nó sẽ giúp họ tiết kiệm rất nhiều chuyển đổi không cần thiết đó.

Câu trả lời ngây thơ và sai lầm ban đầu của tôi :

Chỉ cần tạo (ít nhất) nsố ngẫu nhiên và vật phẩm trao đổi n với vật phẩmi trong vòng lặp for cho mỗi danh sách bạn có.

Trong mã giả:

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

}

Cập nhật:

Cảm ơn the_lotus đã chỉ ra bài báo kinh dị mã hóa. Bây giờ tôi cảm thấy thông minh hơn nhiều :-) Dù sao thì Jeff Atwood cũng chỉ ra cách làm đúng, sử dụng thuật toán 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);
}

Sự khác biệt chính ở đây là mỗi phần tử chỉ được hoán đổi một lần.

Và trong khi các câu trả lời khác giải thích chính xác rằng mô hình đối tượng của bạn bị thiếu sót, bạn có thể không ở trong positioin để thay đổi nó. Vì vậy, thuật toán Fisher-Yates sẽ giải quyết vấn đề của bạn mà không thay đổi mô hình dữ liệu của bạn.