Dlaczego kolekcje Java nie usuwają metod ogólnych?

Dlaczego Collection.remove (Object o) nie jest ogólna?

Wydaje się, że Collection<E>mógłboolean remove(E o);

Następnie, gdy przypadkowo spróbujesz usunąć (na przykład) Set<String>zamiast każdego pojedynczego ciągu z a Collection<String>, byłby to błąd czasu kompilacji zamiast późniejszego problemu z debugowaniem.

Josh Bloch i Bill Pugh odnoszą się do tego problemu w Java Puzzlers IV: The Phantom Reference Menace, Attack of the Clone i Revenge of The Shift .

Josh Bloch mówi (6:41), że próbowali wygenerować metodę pobierania Map, metodę usuwania i kilka innych, ale „to po prostu nie działało”.

Istnieje zbyt wiele rozsądnych programów, których nie można wygenerować, jeśli zezwolisz tylko na typ ogólny kolekcji jako typ parametru. Podany przez niego przykład to przecięcie a Listz Numbersi a Listz Longs.

remove()(in Maporaz in Collection) nie jest typowe, ponieważ powinieneś być w stanie przekazać dowolny typ obiektu do remove(). Usunięty obiekt nie musi być tego samego typu, co obiekt, do którego przekazujesz remove(); wymaga tylko, aby byli równi. W opisie remove(), remove(o)usuwa obiektu etak, że (o==null ? e==null : o.equals(e))jest true. Zauważ, że nie ma nic wymagającego oi ebyć tego samego typu. Wynika to z faktu, że equals()metoda przyjmuje Objectparametr as, a nie tylko ten sam typ, co obiekt.

Chociaż może być powszechnie prawdą, że wiele klas zostało equals()zdefiniowanych tak, że ich obiekty mogą być równe tylko obiektom swojej własnej klasy, z pewnością nie zawsze tak jest. Na przykład specyfikacja dla List.equals()mówi, że dwa obiekty List są równe, jeśli oba są Listami i mają tę samą zawartość, nawet jeśli są różnymi implementacjami List. Wracając do przykładu w tym pytaniu, możliwe jest Map<ArrayList, Something>wywołanie a i dla mnie remove()z LinkedListargumentem jako, i powinno to usunąć klucz, który jest listą o tej samej zawartości. Nie byłoby to możliwe, gdyby remove()były ogólne i ograniczały typ argumentu.

Ponieważ jeśli parametr typu jest symbolem wieloznacznym, nie można użyć ogólnej metody usuwania.

Wydaje mi się, że natknąłem się na to pytanie z metodą Get (Object) Map. Metoda get w tym przypadku nie jest ogólna, chociaż powinna rozsądnie oczekiwać, że zostanie przekazany obiekt tego samego typu, co pierwszy parametr typu. Zdałem sobie sprawę, że jeśli przekazujesz Mapy z symbolem wieloznacznym jako pierwszym parametrem typu, nie ma sposobu, aby uzyskać element z mapy za pomocą tej metody, jeśli ten argument był ogólny. Argumenty symboli wieloznacznych nie mogą być tak naprawdę spełnione, ponieważ kompilator nie może zagwarantować, że typ jest poprawny. Spekuluję, że powodem dodania jest to, że oczekuje się, że przed dodaniem go do kolekcji należy zagwarantować, że typ jest poprawny. Jednak podczas usuwania obiektu, jeśli typ jest nieprawidłowy, i tak nie będzie pasował.

Prawdopodobnie nie wyjaśniłem tego zbyt dobrze, ale wydaje mi się to wystarczająco logiczne.

Oprócz innych odpowiedzi istnieje jeszcze jeden powód, dla którego metoda powinna akceptować an Object, czyli predykaty. Rozważ następujący przykład:

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

Chodzi o to, że obiekt przekazywany do removemetody jest odpowiedzialny za zdefiniowanie equalsmetody. Budowanie predykatów staje się w ten sposób bardzo proste.

Załóżmy, jeden posiada kolekcję Cat, a niektóre odniesienia Przedmiot typów Animal, Cat, SiameseCati Dog. Zadawanie kolekcję, czy zawiera on przedmiotu wskazuje się przez podanie Catlub SiameseCatodniesienie wydaje się rozsądny. Pytanie, czy zawiera obiekt, do którego Animalodnosi się odwołanie, może wydawać się podejrzane, ale nadal jest całkowicie uzasadnione. Przedmiotowy obiekt może w końcu być a Cati może pojawić się w kolekcji.

Co więcej, nawet jeśli obiekt jest czymś innym niż a Cat, nie ma problemu z stwierdzeniem, czy występuje w kolekcji - wystarczy odpowiedzieć „nie, nie ma”. Pewnego typu kolekcja w stylu wyszukiwania powinna być w stanie w znaczący sposób akceptować odwołania do dowolnego nadtypu i określać, czy obiekt istnieje w kolekcji. Jeśli przekazane odwołanie do obiektu jest niepowiązanego typu, nie ma możliwości, aby kolekcja mogła go zawierać, więc zapytanie jest w pewnym sensie bez znaczenia (zawsze odpowie „nie”). Niemniej jednak, ponieważ nie ma sposobu na ograniczenie parametrów do podtypów lub nadtypów, najbardziej praktyczne jest po prostu zaakceptowanie dowolnego typu i udzielenie odpowiedzi „nie” dla obiektów, których typ nie jest powiązany z typem kolekcji.

Zawsze myślałem, że dzieje się tak, ponieważ remove () nie ma powodu, by przejmować się typem obiektu, który mu podasz. Niezależnie od tego, łatwo jest sprawdzić, czy ten obiekt jest jednym z tych, które zawiera Kolekcja, ponieważ może wywołać equals () na czymkolwiek. Konieczne jest sprawdzenie typu w add (), aby upewnić się, że zawiera tylko obiekty tego typu.

To był kompromis. Oba podejścia mają swoją zaletę:

• remove(Object o)
  • jest bardziej elastyczny. Na przykład pozwala na iterację listy numerów i usunięcie ich z listy długich.
  • kod korzystający z tej elastyczności można łatwiej wygenerować
• remove(E e) zapewnia większe bezpieczeństwo typów do tego, co większość programów chce zrobić, wykrywając subtelne błędy w czasie kompilacji, na przykład omyłkową próbę usunięcia liczby całkowitej z listy skrótów.

Kompatybilność wsteczna zawsze była głównym celem podczas ewolucji API Java, dlatego wybrano opcję remove (Object o), ponieważ ułatwiło to generowanie istniejącego kodu. Gdyby kompatybilność wsteczna NIE była problemem, myślę, że projektanci wybraliby usuń (E e).

Remove nie jest metodą ogólną, więc istniejący kod korzystający z kolekcji innej niż ogólna będzie nadal kompilowany i nadal będzie miał takie samo zachowanie.

Szczegółowe informacje można znaleźć pod adresem http://www.ibm.com/developerworks/java/library/j-jtp01255.html .

Edycja: komentator pyta, dlaczego metoda dodawania jest ogólna. [... usunąłem moje wyjaśnienie ...] Drugi komentator odpowiedział na pytanie od firebird84 znacznie lepiej niż ja.

Innym powodem są interfejsy. Oto przykład, aby to pokazać:

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

Ponieważ spowodowałoby to uszkodzenie istniejącego kodu (sprzed wersji Java5). na przykład,

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

Teraz możesz powiedzieć, że powyższy kod jest błędny, ale przypuśćmy, że o pochodzi z heterogenicznego zbioru obiektów (tj. Zawiera łańcuchy, liczbę, obiekty itp.). Chcesz usunąć wszystkie dopasowania, co było legalne, ponieważ remove zignorowałoby po prostu elementy niebędące ciągami, ponieważ nie były równe. Ale jeśli usuniesz (String o), to już nie działa.