Tại sao Bộ sưu tập Java không xóa các phương thức chung chung?

Tại sao không phải là Collection.remove (Object o) chung chung?

Có vẻ như Collection<E>có thể cóboolean remove(E o);

Sau đó, khi bạn vô tình cố gắng loại bỏ (ví dụ) Set<String>thay vì từng Chuỗi riêng lẻ từ a Collection<String>, đó sẽ là lỗi thời gian biên dịch thay vì vấn đề gỡ lỗi sau này.

Josh Bloch và Bill Pugh đề cập đến vấn đề này trong Java Puzzlers IV: The Phantom Reference Menace, Attack of the Clone và Revenge of The Shift .

Josh Bloch nói (6:41) rằng họ đã cố gắng tạo ra phương pháp lấy bản đồ, loại bỏ phương thức này và một số phương pháp khác, nhưng "đơn giản là nó không hoạt động".

Có quá nhiều chương trình hợp lý không thể khái quát nếu bạn chỉ cho phép loại chung của bộ sưu tập là loại tham số. Ví dụ được đưa ra bởi anh ta là một giao điểm của a Listcủa Numbers và a Listcủa Longs.

remove()(trong Mapcũng như trong Collection) không chung chung vì bạn sẽ có thể chuyển trong bất kỳ loại đối tượng nào remove(). Đối tượng bị loại bỏ không phải cùng loại với đối tượng mà bạn truyền vào remove(); nó chỉ yêu cầu họ bằng nhau Từ đặc điểm kỹ thuật của remove(), remove(o)loại bỏ các đối tượng eđó (o==null ? e==null : o.equals(e))là true. Lưu ý rằng không có gì yêu cầu ovà ephải cùng loại. Điều này xuất phát từ thực tế là equals()phương thức lấy một Objecttham số, không chỉ cùng loại với đối tượng.

Mặc dù, có thể đúng là nhiều lớp đã equals()định nghĩa sao cho các đối tượng của nó chỉ có thể bằng với các đối tượng của lớp của chính nó, điều đó chắc chắn không phải luôn luôn như vậy. Ví dụ, đặc tả cho List.equals()biết hai đối tượng List bằng nhau nếu cả hai đều là List và có cùng nội dung, ngay cả khi chúng là các cách triển khai khác nhau List. Vì vậy, quay trở lại ví dụ trong câu hỏi này, có thể có một Map<ArrayList, Something>và để tôi gọi remove()với một LinkedListđối số là, và nó sẽ xóa khóa đó là một danh sách có cùng nội dung. Điều này sẽ không thể xảy ra nếu remove()chung chung và hạn chế loại đối số của nó.

Bởi vì nếu tham số loại của bạn là ký tự đại diện, bạn không thể sử dụng phương thức xóa chung.

Tôi dường như nhớ lại việc chạy vào câu hỏi này với phương thức get (Object) của Map. Phương thức get trong trường hợp này không chung chung, mặc dù vậy, nó sẽ mong đợi được truyền một đối tượng cùng loại với tham số loại đầu tiên. Tôi nhận ra rằng nếu bạn đi xung quanh Bản đồ với ký tự đại diện làm tham số loại đầu tiên, thì không có cách nào để đưa một phần tử ra khỏi Bản đồ bằng phương thức đó, nếu đối số đó là chung. Đối số ký tự đại diện không thể thực sự hài lòng, vì trình biên dịch không thể đảm bảo rằng loại này là chính xác. Tôi suy đoán rằng lý do add là chung chung là bạn dự kiến ​​sẽ đảm bảo rằng loại này là chính xác trước khi thêm nó vào bộ sưu tập. Tuy nhiên, khi xóa một đối tượng, nếu loại không chính xác thì dù sao nó cũng không khớp.

Tôi có lẽ đã không giải thích nó rất tốt, nhưng nó có vẻ hợp lý với tôi.

Ngoài các câu trả lời khác, có một lý do khác tại sao phương thức nên chấp nhận một Object, đó là các vị ngữ. Hãy xem xét các mẫu sau:

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

Vấn đề là đối tượng được truyền cho removephương thức có trách nhiệm xác định equalsphương thức. Xây dựng vị ngữ trở nên rất đơn giản theo cách này.

Giả sử ta có một bộ sưu tập Cat, và một số tài liệu tham khảo đối tượng các loại Animal, Cat, SiameseCat, và Dog. Hỏi bộ sưu tập xem nó có chứa đối tượng được tham chiếu bởi Cathoặc SiameseCattham chiếu có vẻ hợp lý không. Hỏi xem nó có chứa đối tượng được Animaltham chiếu bởi tham chiếu có vẻ tinh ranh không, nhưng nó vẫn hoàn toàn hợp lý. Rốt cuộc, đối tượng trong câu hỏi có thể là một Catvà có thể xuất hiện trong bộ sưu tập.

Hơn nữa, ngay cả khi đối tượng tình cờ là một thứ gì đó không phải là một Cat, không có vấn đề gì cho biết liệu nó có xuất hiện trong bộ sưu tập hay không - chỉ cần trả lời "không, nó không". Một bộ sưu tập "kiểu tra cứu" của một số loại sẽ có thể chấp nhận một cách có ý nghĩa tham chiếu của bất kỳ siêu kiểu nào và xác định xem đối tượng có tồn tại trong bộ sưu tập hay không. Nếu tham chiếu đối tượng được truyền vào là loại không liên quan, thì không có cách nào bộ sưu tập có thể chứa nó, do đó, truy vấn theo nghĩa nào đó không có ý nghĩa (nó sẽ luôn trả lời "không"). Tuy nhiên, vì không có cách nào để hạn chế các tham số thành các kiểu con hoặc siêu kiểu, nên thực tế nhất là chấp nhận bất kỳ loại nào và trả lời "không" cho bất kỳ đối tượng nào có loại không liên quan đến bộ sưu tập.

Tôi luôn luôn nghĩ rằng điều này là do remove () không có lý do để quan tâm loại đối tượng bạn cung cấp cho nó. Bất kể đủ dễ dàng để kiểm tra xem đối tượng đó có phải là một trong những đối tượng mà Bộ sưu tập chứa hay không, vì nó có thể gọi bằng () trên bất cứ thứ gì. Cần kiểm tra loại trên add () để đảm bảo rằng nó chỉ chứa các đối tượng của loại đó.

Đó là một sự thỏa hiệp. Cả hai phương pháp đều có ưu điểm của chúng:

• remove(Object o)
  • linh hoạt hơn. Ví dụ, nó cho phép lặp qua một danh sách các số và xóa chúng khỏi danh sách dài.
  • mã sử dụng tính linh hoạt này có thể được tạo ra dễ dàng hơn
• remove(E e) mang lại nhiều loại an toàn hơn cho những gì hầu hết các chương trình muốn làm bằng cách phát hiện các lỗi tinh vi tại thời điểm biên dịch, như cố gắng xóa nhầm một số nguyên khỏi danh sách quần short.

Khả năng tương thích ngược luôn là mục tiêu chính khi phát triển API Java, do đó loại bỏ (Object o) đã được chọn vì nó giúp việc tạo mã hiện có dễ dàng hơn. Nếu khả năng tương thích ngược KHÔNG phải là vấn đề, tôi đoán các nhà thiết kế đã chọn loại bỏ (E e).

Xóa không phải là một phương thức chung để mã hiện có sử dụng bộ sưu tập không chung chung sẽ vẫn biên dịch và vẫn có hành vi tương tự.

Xem http://www.ibm.com/developerworks/java/l Library / j-jtp01255.html để biết chi tiết.

Chỉnh sửa: Một người bình luận hỏi tại sao phương thức add là chung chung. [... đã xóa lời giải thích của tôi ...] Bình luận viên thứ hai trả lời câu hỏi từ firebird84 tốt hơn tôi rất nhiều.

Một lý do khác là vì các giao diện. Dưới đây là một ví dụ để hiển thị nó:

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 */
}

Bởi vì nó sẽ phá vỡ mã (tiền Java5) hiện có. ví dụ,

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

Bây giờ bạn có thể nói đoạn mã trên là sai, nhưng giả sử o đến từ một tập hợp các đối tượng không đồng nhất (nghĩa là nó chứa các chuỗi, số, đối tượng, v.v.). Bạn muốn xóa tất cả các kết quả khớp, đó là hợp pháp vì loại bỏ sẽ chỉ bỏ qua các chuỗi không phải vì chúng không bằng nhau. Nhưng nếu bạn loại bỏ nó (Chuỗi o), thì nó không còn hoạt động nữa.