ทำไม Java Collections จึงไม่ลบเมธอดทั่วไป?

ทำไมไม่ Collection.remove (Object o)ทั่วไป?

ดูเหมือนว่า Collection<E>จะมีboolean remove(E o);

จากนั้นเมื่อคุณพยายามลบ (ตัวอย่าง) โดยไม่ได้ตั้งใจSet<String>แทนที่จะใช้สตริงแต่ละอันจาก a Collection<String>มันจะเป็นข้อผิดพลาดเวลาในการคอมไพล์แทนที่จะเป็นปัญหาการดีบักในภายหลัง

Josh Bloch และ Bill Pugh อ้างถึงปัญหานี้ในJava Puzzlers IV: The Phantom Reference Menace, Attack of the Clone และ Revenge of The Shiftผีอ้างอิงคุกคามการโจมตีของโคลนและการแก้แค้นของกดปุ่ม Shift

Josh Bloch กล่าวว่า (6:41) ว่าพวกเขาพยายามสร้างวิธีการรับแผนที่ลบวิธีการและอื่น ๆ แต่ "มันใช้งานไม่ได้"

มีโปรแกรมที่สมเหตุสมผลมากเกินไปที่ไม่สามารถสร้างได้หากคุณอนุญาตประเภททั่วไปของการรวบรวมเป็นประเภทพารามิเตอร์ ตัวอย่างที่ได้รับจากเขาเป็นจุดตัดของListของNumbers และ ListของLongs

remove()(ในMapเช่นเดียวกับในCollection) ไม่ได้ทั่วไปเพราะคุณควรจะสามารถที่จะผ่านในรูปแบบใด ๆ remove()ของวัตถุ วัตถุที่เอาออกไม่จำเป็นต้องเป็นชนิดเดียวกับวัตถุที่คุณผ่านไปremove(); มันต้องการเพียงแค่ว่าพวกเขาจะเท่ากัน จากคุณสมบัติของremove(), remove(o)เอาวัตถุeดังกล่าวว่าเป็น(o==null ? e==null : o.equals(e)) trueโปรดทราบว่าไม่มีอะไรที่ต้องใช้oและeเป็นประเภทเดียวกัน นี้ตามมาจากความจริงที่ว่าequals()วิธีการที่ใช้ในการObjectพารามิเตอร์ as ไม่ใช่แค่ชนิดเดียวกับวัตถุ

แม้ว่ามันอาจจะเป็นความจริงโดยทั่วไปที่คลาสจำนวนมากได้equals()กำหนดไว้เพื่อให้อ็อบเจ็กต์สามารถเท่ากับอ็อบเจ็กต์ของคลาสของตัวเองเท่านั้นซึ่งแน่นอนว่าไม่เสมอไป ยกตัวอย่างเช่นข้อกำหนดสำหรับบอกว่าวัตถุทั้งสองรายการมีค่าเท่ากันถ้าหากพวกเขาทั้งสองรายการและมีเนื้อหาเดียวกันแม้ว่าพวกเขาจะใช้งานที่แตกต่างกันของList.equals() Listดังนั้นกลับมาที่ตัวอย่างในคำถามนี้มันเป็นไปได้ที่จะมีMap<ArrayList, Something>และสำหรับฉันที่จะโทรremove()ด้วยLinkedListเป็นอาร์กิวเมนต์และควรลบที่สำคัญซึ่งเป็นรายการที่มีเนื้อหาเดียวกัน สิ่งนี้จะเป็นไปไม่ได้หากremove()เป็นประเภททั่วไปและ จำกัด ประเภทอาร์กิวเมนต์

เนื่องจากหากพารามิเตอร์ประเภทของคุณเป็นไวด์การ์ดคุณจะไม่สามารถใช้วิธีลบทั่วไปได้

ฉันดูเหมือนจะจำการทำงานของคำถามนี้ด้วยวิธีการของแผนที่ (วัตถุ) วิธีการรับในกรณีนี้ไม่ใช่แบบทั่วไปถึงแม้ว่ามันควรจะคาดหวังอย่างสมเหตุสมผลว่าจะต้องผ่านวัตถุประเภทเดียวกันกับพารามิเตอร์ประเภทแรก ฉันรู้ว่าถ้าคุณผ่านแผนที่ที่มีสัญลักษณ์ตัวแทนเป็นพารามิเตอร์ประเภทแรกก็ไม่มีทางที่จะได้รับองค์ประกอบออกจากแผนที่ด้วยวิธีการนี้หากข้อโต้แย้งนั้นเป็นเรื่องทั่วไป อาร์กิวเมนต์ของ Wildcard ไม่สามารถสร้างความพึงพอใจได้จริงเพราะคอมไพเลอร์ไม่สามารถรับประกันได้ว่าประเภทนั้นถูกต้อง ฉันคาดการณ์ว่าเหตุผลการเพิ่มนั้นเป็นเรื่องทั่วไปคือคุณคาดว่าจะรับประกันได้ว่าประเภทนั้นถูกต้องก่อนที่จะเพิ่มลงในคอลเลกชัน อย่างไรก็ตามเมื่อนำวัตถุออกหากประเภทไม่ถูกต้องวัตถุนั้นจะไม่ตรงกับสิ่งใดเลย

ฉันอาจไม่ได้อธิบายได้ดี แต่ดูเหมือนว่าสมเหตุสมผลสำหรับฉัน

นอกเหนือจากคำตอบอื่น ๆ แล้วยังมีอีกเหตุผลที่วิธีการที่ควรยอมรับObjectซึ่งเป็นเพรดิเคต พิจารณาตัวอย่างต่อไปนี้:

class Person {
    public String name;
    // override equals()
}
class Employee extends Person {
    public String company;
    // override equals()
}
class Developer extends Employee {
    public int yearsOfExperience;
    // override equals()
}

class Test {
    public static void main(String[] args) {
        Collection<? extends Person> people = new ArrayList<Employee>();
        // ...

        // to remove the first employee with a specific name:
        people.remove(new Person(someName1));

        // to remove the first developer that matches some criteria:
        people.remove(new Developer(someName2, someCompany, 10));

        // to remove the first employee who is either
        // a developer or an employee of someCompany:
        people.remove(new Object() {
            public boolean equals(Object employee) {
                return employee instanceof Developer
                    || ((Employee) employee).company.equals(someCompany);
        }});
    }
}

ประเด็นก็คือวัตถุที่ถูกส่งผ่านไปยังremoveวิธีการมีหน้าที่รับผิดชอบในการกำหนดequalsวิธีการ การสร้างภาคแสดงเป็นวิธีที่ง่ายมาก

สมมติหนึ่งที่มีคอลเลกชันของCatและบางส่วนอ้างอิงวัตถุประเภทAnimal, Cat, และSiameseCat Dogการถามคอลเลกชันว่ามีวัตถุที่อ้างถึงโดยCatหรือSiameseCatการอ้างอิงดูเหมือนว่าเหมาะสม การถามว่ามันมีวัตถุที่อ้างถึงโดยAnimalอ้างอิงอาจดูเหมือนหลบ แต่มันก็ยังสมเหตุสมผล วัตถุที่เป็นปัญหาอาจจะเป็นCatและอาจปรากฏในคอลเล็กชัน

นอกจากนี้แม้ว่าวัตถุจะเป็นอย่างอื่นนอกเหนือจาก a Catก็ไม่มีปัญหาที่จะบอกได้ว่ามันปรากฏอยู่ในคอลเลกชันหรือไม่ - เพียงแค่ตอบว่า "ไม่เลย" คอลเลกชัน "ลักษณะการค้นหา" ของบางประเภทควรจะสามารถยอมรับการอ้างอิงของ supertype ใด ๆ ได้อย่างมีความหมายและตัดสินว่าวัตถุนั้นมีอยู่ภายในคอลเลกชันหรือไม่ หากการอ้างอิงวัตถุที่ผ่านเป็นประเภทที่ไม่เกี่ยวข้องไม่มีวิธีที่จะเก็บอาจมีดังนั้นแบบสอบถามในความรู้สึกที่ไม่มีความหมายบางอย่าง (มันมักจะตอบว่า "ไม่") อย่างไรก็ตามเนื่องจากไม่มีวิธีใดที่จะ จำกัด พารามิเตอร์ให้เป็นประเภทย่อยหรือ supertypes จึงเป็นไปได้มากที่สุดที่จะยอมรับประเภทและคำตอบ "ไม่" สำหรับวัตถุใด ๆ ที่ประเภทนั้นไม่เกี่ยวข้องกับการรวบรวม

ฉันคิดเสมอว่านี่เป็นเพราะ remove () ไม่มีเหตุผลที่จะสนใจว่าคุณให้วัตถุประเภทใด มันง่ายพอโดยไม่คำนึงว่าจะตรวจสอบว่าวัตถุนั้นเป็นหนึ่งในสิ่งที่คอลเล็กชันมีอยู่หรือไม่เพราะสามารถเรียกว่าเท่ากับ () กับอะไรก็ได้ จำเป็นต้องตรวจสอบประเภทของการเพิ่ม () เพื่อให้แน่ใจว่ามีเพียงวัตถุประเภทนั้น ๆ

มันเป็นการประนีประนอม ทั้งสองวิธีมีข้อได้เปรียบ:

• remove(Object o)
  • มีความยืดหยุ่นมากขึ้น ตัวอย่างเช่นมันอนุญาตให้วนซ้ำผ่านรายการตัวเลขและลบออกจากรายการ longs
  • รหัสที่ใช้ความยืดหยุ่นนี้สามารถสร้างได้ง่ายขึ้น
• remove(E e) ทำให้มีความปลอดภัยมากขึ้นในสิ่งที่โปรแกรมส่วนใหญ่ต้องการทำโดยตรวจหาข้อบกพร่องที่ละเอียด ณ เวลารวบรวมเช่นพยายามลบจำนวนเต็มออกจากรายการกางเกงขาสั้นโดยไม่ตั้งใจ

ความเข้ากันได้ย้อนหลังเป็นเป้าหมายสำคัญเสมอเมื่อพัฒนา Java API ดังนั้นจึงเลือกลบ (Object o) เนื่องจากทำให้การสร้างโค้ดที่มีอยู่ง่ายขึ้น หากความเข้ากันได้ย้อนหลังไม่เป็นปัญหาฉันเดาว่านักออกแบบจะเลือกลบ (E e)

การลบไม่ใช่วิธีทั่วไปเพื่อให้รหัสที่มีอยู่ซึ่งใช้คอลเลกชันที่ไม่ใช่ทั่วไปจะยังคงรวบรวมและยังคงมีพฤติกรรมเดียวกัน

ดูhttp://www.ibm.com/developerworks/java/library/j-jtp01255.htmlเพื่อดูรายละเอียด

แก้ไข: ผู้วิจารณ์ถามว่าทำไมวิธีการเพิ่มจึงเป็นเรื่องทั่วไป [... ลบคำอธิบายของฉัน ... ] ผู้วิจารณ์คนที่สองตอบคำถามจาก firebird84 ดีกว่าฉันมาก

อีกสาเหตุหนึ่งก็เพราะอินเตอร์เฟซ นี่คือตัวอย่างที่จะแสดง:

public interface A {}

public interface B {}

public class MyClass implements A, B {}

public static void main(String[] args) {
   Collection<A> collection = new ArrayList<>();
   MyClass item = new MyClass();
   collection.add(item);  // works fine
   B b = item; // valid
   collection.remove(b); /* It works because the remove method accepts an Object. If it was generic, this would not work */
}

เพราะมันจะทำลายรหัส (pre-Java5) ที่มีอยู่ เช่น,

Set stringSet = new HashSet();
// do some stuff...
Object o = "foobar";
stringSet.remove(o);

ตอนนี้คุณอาจพูดได้ว่าโค้ดด้านบนผิด แต่สมมติว่า o มาจากชุดของวัตถุที่ต่างกัน (เช่นมันมีสตริงจำนวนวัตถุ ฯลฯ ) คุณต้องการที่จะลบการแข่งขันทั้งหมดซึ่งถูกกฎหมายเพราะการลบก็จะไม่สนใจสตริงที่ไม่ได้เพราะพวกเขาไม่เท่ากัน แต่ถ้าคุณลบมันออก (String o) มันจะไม่ทำงานอีกต่อไป