วิธีที่มีประสิทธิภาพในการสลับวัตถุ

ฉันกำลังเขียนโปรแกรมสำหรับซอฟต์แวร์ตอบคำถาม ฉันมีชั้นคำถามที่มี ArrayLists สำหรับคำถามคำตอบตัวเลือกเครื่องหมายและเครื่องหมายลบ บางสิ่งเช่นนี้

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

ฉันต้องการสลับคำถามทั้งหมด แต่สำหรับคำถามที่จะสับได้วัตถุทั้งหมดต้องถูกสับ ฉันจะเข้าหาปัญหานี้ด้วยวิธีนี้:

ก่อนอื่นฉันจะไม่ใช้การออกแบบนี้และใช้ String ที่ไม่ArrayList<String>พิมพ์เป็นตัวแปรอินสแตนซ์และจากนั้นจะใช้Collections.shuffleวิธีการสลับวัตถุ แต่ทีมของฉันยืนยันในการออกแบบนี้

ตอนนี้คลาสคำถามจะมี ArrayLists ที่เพิ่มขึ้นเมื่อมีการป้อนคำถาม จะสลับคำถามได้อย่างไร

ทีมงานของคุณทนทุกข์ทรมานจากปัญหาที่พบบ่อย: ปฏิเสธวัตถุ

แทนที่จะเป็นคลาสที่มีคำถามเดียวซึ่งมีข้อมูลทั้งหมดที่เกี่ยวข้องคุณพยายามสร้างคลาสที่เรียกว่าquestionที่เก็บคำถามทั้งหมดไว้ในอินสแตนซ์เดียว

นั่นเป็นวิธีที่ผิดที่จะไปเกี่ยวกับมันและมันซับซ้อนสิ่งที่คุณพยายามทำมาก ! การเรียงลำดับ (และการสับ) อาร์เรย์ขนาน (หรือรายการ) เป็นธุรกิจที่น่ารังเกียจและไม่มี API ทั่วไปสำหรับมันเพียงเพราะคุณมักจะต้องการหลีกเลี่ยงเลย

ฉันขอแนะนำให้คุณปรับโครงสร้างรหัสของคุณเช่นนี้:

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

ด้วยวิธีนี้การสลับคำถามของคุณกลายเป็นเรื่องเล็กน้อย (โดยใช้Collections.shuffle()):

Collections.shuffle(questionList);

คุณทำไม่ได้ คุณสร้างรายการ / คิวของดัชนีและสลับแบบนั้น จากนั้นคุณทำซ้ำดัชนีซึ่งจะทำให้ลำดับ "สับ" ของคอลเลกชันอื่น ๆ ของคุณ

แม้จะอยู่นอกสถานการณ์ของคุณด้วยสิ่งที่แยกออกจากกันคอลเลกชันการสั่งซื้อแยกต่างหากก็ให้ประโยชน์มากมาย

ฉันเห็นด้วยกับคำตอบอื่น ๆ ว่าวิธีการแก้ปัญหาที่ถูกต้องคือการใช้แบบจำลองวัตถุที่เหมาะสม

อย่างไรก็ตามเป็นเรื่องง่ายมากที่จะสลับหลายรายการในลักษณะเดียวกัน:

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

สร้างคลาสQuestion2:

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

แล้วสร้างแผนที่ฟังก์ชั่นquestionการArrayList<Question2>ใช้งานCollection.Shuffleเพื่อให้ได้ผลลัพธ์ที่และสร้างฟังก์ชั่นที่สองสำหรับการทำแผนที่กลับไปArrayList<Question2>question

หลังจากนั้นไปที่ทีมของคุณและพยายามโน้มน้าวพวกเขาว่าการใช้รหัสArrayList<Question2>แทนที่จะquestionปรับปรุงรหัสของพวกเขาเป็นจำนวนมากเนื่องจากจะช่วยให้พวกเขาได้รับการแปลงที่ไม่จำเป็นจำนวนมาก

คำตอบเดิม ๆ ที่ไร้เดียงสาและผิดของฉัน:

เพียงสร้างnตัวเลขสุ่ม(อย่างน้อย) และรายการแลกเปลี่ยนn กับรายการiในลูปสำหรับแต่ละรายการที่คุณมี

ในรหัสเทียม:

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

}

ปรับปรุง:

ขอบคุณสำหรับ the_lotus ที่ชี้ให้เห็นถึงบทความสยองขวัญที่เข้ารหัส ฉันรู้สึกชาญฉลาดขึ้นมากในขณะนี้ :-) อย่างไรก็ตาม Jeff Atwood ยังแสดงให้เห็นว่าทำอย่างไรให้ถูกต้องโดยใช้อัลกอริทึม 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);
}

ความแตกต่างที่สำคัญที่นี่คือแต่ละองค์ประกอบมีการสลับเพียงครั้งเดียว

และในขณะที่คำตอบอื่น ๆ อย่างถูกต้องอธิบายว่าแบบจำลองวัตถุของคุณมีข้อบกพร่องคุณอาจไม่อยู่ในตำแหน่งที่จะเปลี่ยน ดังนั้นอัลกอริทึม Fisher-Yates จะแก้ปัญหาของคุณโดยไม่ต้องเปลี่ยนรูปแบบข้อมูลของคุณ