Nesneleri karıştırmanın etkili yolu

Bazı sınav yazılımları için bir program yazıyorum. Soru, cevap, seçenekler, işaretler ve negatif işaretler için ArrayLists içeren bir soru sınıfı var. Bunun gibi bir şey:

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üm soruları karıştırmak istiyorum, ancak soruların karıştırılması için tüm nesnelerin karıştırılması gerekiyor. Bu soruna şu şekilde yaklaşırdım:

Her şeyden önce, bu tasarımı kullanmazdım ve ArrayList<String>örnek değişkenleri olarak yazmaz String'i kullanmazdım ve daha sonra Collections.shuffleyöntemi nesneleri karıştırmak için kullanırdı. Ancak ekibim bu tasarımda ısrar ediyor.

Şimdi soru sınıfı, sorulara giriş yapılırken artan ArrayLists içeriyor. Soruları şimdi nasıl karıştırırım?

Ekibiniz ortak bir sorundan muzdarip: nesne reddetme .

İlişkili tüm bilgileri içeren tek bir soru içeren bir sınıf questionyerine, tüm soruları tek bir örnekte tutan adlı bir sınıf oluşturmaya çalışırsınız .

Bu konuda yanlış bir yol var ve çok yapmaya çalıştığınız şeyi zorlaştırıyor ! Paralel dizileri (veya Listeleri) sıralamak (ve karıştırmak) kötü bir iştir ve bunun için ortak bir API yoktur, çünkü genellikle bundan kaçınmak istersiniz .

Kodunuzu şu şekilde yeniden yapılandırmanızı öneririm:

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

Bu şekilde, sorunuzun karıştırılması önemsiz hale gelir (kullanarak Collections.shuffle()):

Collections.shuffle(questionList);

Yapmazsın. Dizinlerin başka bir listesini / sırasını oluşturursunuz ve karıştırırsınız. Ardından, diğer koleksiyonlarınızın "karıştırılmış" sırasını yönlendiren dizinleri yineleyin.

Senaryonuzun dışında bölünmüş şeylerle bile olsa, ayrı sipariş koleksiyonu bir takım faydalar sağlar (paralellik, orijinal koleksiyonu yeniden yüklerken hız, vb.).

Diğer cevaplara, doğru çözümün uygun bir nesne modeli kullanmak olduğuna katılıyorum.

Bununla birlikte, birden fazla listeyi aynı şekilde karıştırmak oldukça kolaydır:

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

Bir sınıf oluşturun Question2:

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

Sonra bir haritalama bir işlevi oluşturmak questioniçin ArrayList<Question2>kullanımı, Collection.Shufflebu sonucun, ve haritalama için ikinci işlevi oluşturun ArrayList<Question2>için arka question.

Daha sonra, ekibinize gidin ve bir ArrayList<Question2>yerine kullanmanın questionkodlarını çok fazla geliştireceğine ikna etmeye çalışın , çünkü bu gereksiz dönüşümlerin çoğunu kurtaracaktır.

Orijinal naif ve yanlış cevabım:

Sadece (en azından) nrasgele sayılar oluşturun ve n sahip iolduğunuz her liste için for döngüsünde öğe ile değişim yapın .

Sahte kodda:

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

}

Güncelleme:

Kodlama korku makalesini işaret ettiğiniz için the_lotus için teşekkürler. Şimdi çok daha akıllı hissediyorum :-) Her neyse Jeff Atwood da Fisher-Yates algoritmasını kullanarak nasıl doğru yapılacağını gösteriyor :

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

Buradaki ana fark, her bir elemanın sadece bir kez değiştirilmesidir.

Diğer cevaplar nesne modelinizin kusurlu olduğunu doğru bir şekilde açıklasa da, değiştirmek için pozitioin içinde olmayabilirsiniz. Fisher-Yates algoritması, sorununuzu veri modelinizi değiştirmeden çözecektir.