Mengapa Koleksi Java tidak menghapus metode yang umum?

Mengapa Collection.remove (Object o) tidak generik?

Sepertinya Collection<E>bisa sajaboolean remove(E o);

Kemudian, ketika Anda secara tidak sengaja mencoba untuk menghapus (misalnya) Set<String>alih-alih setiap String individu dari a Collection<String>, itu akan menjadi kesalahan waktu kompilasi alih-alih masalah debugging nanti.

Josh Bloch dan Bill Pugh merujuk pada masalah ini di Java Puzzlers IV: The Phantom Reference Menace, Attack of the Clone, dan Revenge of The Shift .

Josh Bloch mengatakan (6:41) bahwa mereka berusaha membuat metode get get Map, menghapus metode dan lainnya, tetapi "itu tidak berhasil".

Ada terlalu banyak program masuk akal yang tidak dapat dibuat jika Anda hanya mengizinkan tipe umum koleksi sebagai tipe parameter. Contoh yang diberikan oleh dia adalah persimpangan a Listdari Numberdan Listdari Longs.

remove()(dalam Mapmaupun dalam Collection) tidak generik karena Anda harus dapat meneruskan semua jenis objek remove(). Objek yang dihapus tidak harus bertipe sama dengan objek yang Anda lewati remove(); hanya mensyaratkan bahwa mereka setara. Dari spesifikasi remove(), remove(o)menghapus objek eseperti itu (o==null ? e==null : o.equals(e))adalah true. Perhatikan bahwa tidak ada yang membutuhkan odan ememiliki tipe yang sama. Ini mengikuti dari kenyataan bahwa equals()metode mengambil Objectparameter sebagai, bukan hanya tipe yang sama dengan objek.

Meskipun, mungkin secara umum benar bahwa banyak kelas telah equals()didefinisikan sehingga objeknya hanya bisa sama dengan objek kelasnya sendiri, yang tentu saja tidak selalu demikian. Misalnya, spesifikasi untuk List.equals()mengatakan bahwa dua objek Daftar sama jika keduanya Daftar dan memiliki konten yang sama, bahkan jika mereka berbeda implementasi List. Jadi kembali ke contoh dalam pertanyaan ini, adalah mungkin untuk memiliki Map<ArrayList, Something>dan bagi saya untuk memanggil remove()dengan LinkedListargumen sebagai, dan itu harus menghapus kunci yang merupakan daftar dengan konten yang sama. Ini tidak akan mungkin terjadi jika remove()bersifat generik dan membatasi jenis argumennya.

Karena jika parameter tipe Anda adalah wildcard, Anda tidak dapat menggunakan metode penghapusan generik.

Saya ingat untuk kembali ke pertanyaan ini dengan metode get (Object) Map. Metode get dalam kasus ini tidak generik, meskipun seharusnya diharapkan akan melewati objek dengan tipe yang sama dengan parameter tipe pertama. Saya menyadari bahwa jika Anda mengitari Maps dengan wildcard sebagai parameter tipe pertama, maka tidak ada cara untuk mengeluarkan elemen dari Peta dengan metode itu, jika argumen itu generik. Argumen wildcard tidak dapat benar-benar dipenuhi, karena kompiler tidak dapat menjamin bahwa jenisnya benar. Saya berspekulasi bahwa alasan add bersifat generik adalah karena Anda diharapkan untuk memastikan bahwa jenisnya benar sebelum menambahkannya ke koleksi. Namun, saat menghapus objek, jika jenisnya salah maka tidak akan cocok dengan apa pun.

Saya mungkin tidak menjelaskannya dengan sangat baik, tetapi tampaknya cukup logis bagi saya.

Selain jawaban lain, ada alasan lain mengapa metode ini harus menerima Object, yang merupakan predikat. Pertimbangkan contoh berikut:

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

Intinya adalah bahwa objek yang diteruskan ke removemetode bertanggung jawab untuk mendefinisikan equalsmetode. Membangun predikat menjadi sangat sederhana dengan cara ini.

Asumsikan satu memiliki koleksi Cat, dan beberapa referensi objek jenis Animal, Cat, SiameseCat, dan Dog. Menanyakan koleksi apakah berisi objek yang dirujuk oleh Catatau SiameseCatreferensi tampaknya masuk akal. Bertanya apakah itu berisi objek yang dirujuk oleh Animalreferensi mungkin tampak cerdik, tapi itu masih masuk akal. Objek yang dimaksud mungkin, setelah semua, menjadi aCat , dan mungkin muncul dalam koleksi.

Lebih jauh, bahkan jika objek kebetulan bukan sesuatu yang lain Cat, tidak ada masalah untuk mengatakan apakah itu muncul dalam koleksi - cukup jawab "tidak, tidak". Koleksi "lookup-style" dari beberapa jenis harus dapat menerima referensi supertipe apa pun secara bermakna dan menentukan apakah objek tersebut ada di dalam koleksi. Jika referensi objek yang diteruskan adalah tipe yang tidak terkait, tidak mungkin koleksi tersebut dapat memuatnya, jadi kueri dalam beberapa hal tidak bermakna (itu akan selalu menjawab "tidak"). Meskipun demikian, karena tidak ada cara untuk membatasi parameter menjadi subtipe atau supertipe, itu paling praktis untuk hanya menerima jenis apa pun dan menjawab "tidak" untuk objek apa pun yang jenisnya tidak terkait dengan koleksi.

Saya selalu mengira ini karena remove () tidak punya alasan untuk peduli jenis objek yang Anda berikan. Cukup mudah, apa pun, untuk memeriksa apakah objek itu adalah salah satu yang terdapat dalam Koleksi, karena ia dapat memanggil equals () pada apa pun. Penting untuk memeriksa tipe pada add () untuk memastikan bahwa itu hanya berisi objek dari tipe itu.

Itu kompromi. Kedua pendekatan memiliki keunggulan:

• remove(Object o)
  • lebih fleksibel. Misalnya memungkinkan untuk beralih melalui daftar angka dan menghapusnya dari daftar panjang.
  • kode yang menggunakan fleksibilitas ini dapat lebih mudah dihasilkan
• remove(E e) membawa lebih banyak jenis keamanan untuk apa yang sebagian besar program ingin lakukan dengan mendeteksi bug halus pada waktu kompilasi, seperti keliru mencoba menghapus integer dari daftar celana pendek.

Kompatibilitas mundur selalu menjadi tujuan utama ketika mengembangkan Java API, oleh karena itu hapus (Objek o) dipilih karena membuatnya membuat kode yang ada lebih mudah. Jika kompatibilitas mundur TIDAK menjadi masalah, saya kira para desainer akan memilih hapus (E e).

Hapus bukan metode generik sehingga kode yang ada menggunakan koleksi non-generik akan tetap dikompilasi dan masih memiliki perilaku yang sama.

Lihat http://www.ibm.com/developerworks/java/library/j-jtp01255.html untuk detailnya.

Sunting: Seorang komentator bertanya mengapa metode add bersifat generik. [... menghapus penjelasan saya ...] Komentator kedua menjawab pertanyaan dari firebird84 jauh lebih baik daripada saya.

Alasan lain adalah karena antarmuka. Berikut adalah contoh untuk menunjukkannya:

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

Karena itu akan merusak kode yang ada (pra-Java5). misalnya,

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

Sekarang Anda mungkin mengatakan kode di atas salah, tetapi anggaplah bahwa o berasal dari sekumpulan objek yang heterogen (yaitu berisi string, angka, objek, dll.). Anda ingin menghapus semua pertandingan, yang sah karena menghapus hanya akan mengabaikan non-string karena mereka tidak setara. Tetapi jika Anda membuatnya menghapus (String o), itu tidak lagi berfungsi.