Warum entfernen Java Collections keine generischen Methoden?

Warum ist Collection.remove (Object o) nicht generisch?

Scheint wie Collection<E>könnte habenboolean remove(E o);

Wenn Sie dann versehentlich versuchen, (zum Beispiel) Set<String>anstelle jeder einzelnen Zeichenfolge aus a zu entfernen Collection<String>, handelt es sich um einen Fehler bei der Kompilierung anstelle eines späteren Debugging-Problems.

Josh Bloch und Bill Pugh verweisen auf dieses Problem in Java Puzzlers IV: Die Phantomreferenzbedrohung, Angriff des Klons und Rache der Verschiebung .

Josh Bloch sagt (6:41), dass sie versucht haben, die get-Methode von Map zu generieren, die Methode zu entfernen und einige andere, aber "es hat einfach nicht funktioniert".

Es gibt zu viele sinnvolle Programme, die nicht generiert werden könnten, wenn Sie nur den generischen Typ der Sammlung als Parametertyp zulassen. Das von ihm gegebene Beispiel ist ein Schnittpunkt von a Listvon Numbers und a Listvon Longs.

remove()(in Mapsowie in Collection) ist nicht generisch, da Sie in der Lage sein sollten, jede Art von Objekt an zu übergeben remove(). Das entfernte Objekt muss nicht vom selben Typ sein wie das Objekt, an das Sie übergeben remove(). es erfordert nur, dass sie gleich sind. Aus der Beschreibung der remove(), remove(o)entfernt das Objekt , eso dass (o==null ? e==null : o.equals(e))ist true. Beachten Sie, dass nichts erforderlich ist ound evom selben Typ sein muss. Dies folgt aus der Tatsache, dass die equals()Methode einen Objectas-Parameter akzeptiert, nicht nur denselben Typ wie das Objekt.

Obwohl es allgemein zutreffend sein mag, dass viele Klassen so equals()definiert haben, dass ihre Objekte nur Objekten seiner eigenen Klasse entsprechen können, ist dies sicherlich nicht immer der Fall. In der Spezifikation für List.equals()heißt es beispielsweise, dass zwei Listenobjekte gleich sind, wenn sie beide Listen sind und denselben Inhalt haben, auch wenn es sich um unterschiedliche Implementierungen von handelt List. Wenn wir also auf das Beispiel in dieser Frage zurückkommen, ist es möglich, ein Map<ArrayList, Something>und für mich remove()mit einem LinkedListas-Argument aufzurufen , und es sollte den Schlüssel entfernen, der eine Liste mit demselben Inhalt ist. Dies wäre nicht möglich, wenn remove()der Argumenttyp generisch und eingeschränkt wäre.

Wenn Ihr Typparameter ein Platzhalter ist, können Sie keine generische Entfernungsmethode verwenden.

Ich erinnere mich an diese Frage mit der get (Object) -Methode von Map. Die get-Methode ist in diesem Fall nicht generisch, sollte jedoch vernünftigerweise erwarten, dass ein Objekt des gleichen Typs wie der erste Typparameter übergeben wird. Ich habe festgestellt, dass es mit dieser Methode keine Möglichkeit gibt, ein Element aus der Map zu entfernen, wenn Sie Maps mit einem Platzhalter als erstem Typparameter übergeben, wenn dieses Argument generisch ist. Platzhalterargumente können nicht wirklich erfüllt werden, da der Compiler nicht garantieren kann, dass der Typ korrekt ist. Ich spekuliere, dass der Grund, warum add generisch ist, darin besteht, dass von Ihnen erwartet wird, dass Sie sicherstellen, dass der Typ korrekt ist, bevor Sie ihn der Sammlung hinzufügen. Wenn beim Entfernen eines Objekts der Typ jedoch falsch ist, stimmt er ohnehin mit nichts überein.

Ich habe es wahrscheinlich nicht sehr gut erklärt, aber es scheint mir logisch genug.

Zusätzlich zu den anderen Antworten gibt es einen weiteren Grund, warum die Methode ein ObjectPrädikat akzeptieren sollte . Betrachten Sie das folgende Beispiel:

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

Der Punkt ist, dass das Objekt, das an die removeMethode übergeben wird, für die Definition der equalsMethode verantwortlich ist. Das Erstellen von Prädikaten wird auf diese Weise sehr einfach.

Angenommen , man eine Sammlung von hat Cat, und einige Objektreferenzen von Typen Animal, Cat, SiameseCat, und Dog. Es erscheint vernünftig, die Sammlung zu fragen, ob sie das Objekt enthält, auf das sich die Referenz Catoder die SiameseCatReferenz bezieht. Die Frage, ob es das Objekt enthält, auf das sich die AnimalReferenz bezieht, mag zweifelhaft erscheinen, ist aber dennoch durchaus vernünftig. Das fragliche Objekt könnte schließlich ein sein Catund in der Sammlung erscheinen.

Selbst wenn das Objekt etwas anderes als a ist Cat, ist es kein Problem zu sagen, ob es in der Sammlung erscheint - antworten Sie einfach mit "Nein, tut es nicht". Eine Sammlung im "Lookup-Stil" eines Typs sollte in der Lage sein, Verweise auf einen beliebigen Supertyp sinnvoll zu akzeptieren und festzustellen, ob das Objekt in der Sammlung vorhanden ist. Wenn die übergebene Objektreferenz von einem nicht verwandten Typ ist, kann die Sammlung sie möglicherweise nicht enthalten, sodass die Abfrage in gewissem Sinne nicht aussagekräftig ist (sie antwortet immer mit "Nein"). Da es jedoch keine Möglichkeit gibt, Parameter auf Subtypen oder Supertypen zu beschränken, ist es am praktischsten, einfach einen beliebigen Typ zu akzeptieren und für Objekte, deren Typ nicht mit dem der Sammlung zusammenhängt, mit "Nein" zu antworten.

Ich habe immer gedacht, dass dies daran liegt, dass remove () keinen Grund hat, sich darum zu kümmern, welche Art von Objekt Sie ihm geben. Unabhängig davon ist es einfach genug zu überprüfen, ob dieses Objekt eines der Objekte ist, die in der Sammlung enthalten sind, da es für alles equals () aufrufen kann. Es ist erforderlich, den Typ bei add () zu überprüfen, um sicherzustellen, dass nur Objekte dieses Typs enthalten sind.

Es war ein Kompromiss. Beide Ansätze haben ihren Vorteil:

• remove(Object o)
  • ist flexibler. Zum Beispiel können Sie eine Liste von Zahlen durchlaufen und sie aus einer Liste von Longs entfernen.
  • Code, der diese Flexibilität nutzt, kann einfacher generiert werden
• remove(E e) bringt mehr Typensicherheit für das, was die meisten Programme tun möchten, indem sie beim Kompilieren subtile Fehler erkennen, z. B. den irrtümlichen Versuch, eine Ganzzahl aus einer Liste von Kurzschlüssen zu entfernen.

Die Abwärtskompatibilität war bei der Entwicklung der Java-API immer ein wichtiges Ziel. Daher wurde remove (Object o) ausgewählt, da dies das Generieren von vorhandenem Code erleichtert. Wenn die Abwärtskompatibilität KEIN Problem gewesen wäre, hätten die Designer vermutlich remove (E e) gewählt.

Entfernen ist keine generische Methode, sodass vorhandener Code, der eine nicht generische Sammlung verwendet, weiterhin kompiliert wird und dasselbe Verhalten aufweist.

Weitere Informationen finden Sie unter http://www.ibm.com/developerworks/java/library/j-jtp01255.html .

Bearbeiten: Ein Kommentator fragt, warum die Add-Methode generisch ist. [... meine Erklärung entfernt ...] Der zweite Kommentator beantwortete die Frage von firebird84 viel besser als ich.

Ein weiterer Grund sind Schnittstellen. Hier ist ein Beispiel, um es zu zeigen:

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

Weil es vorhandenen Code (vor Java5) beschädigen würde. z.B,

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

Nun könnten Sie sagen, dass der obige Code falsch ist, aber nehmen Sie an, dass o aus einer heterogenen Menge von Objekten stammt (dh Zeichenfolgen, Zahlen, Objekte usw. enthält). Sie möchten alle Übereinstimmungen entfernen, was legal war, da beim Entfernen die Nicht-Zeichenfolgen einfach ignoriert wurden, weil sie nicht gleich waren. Aber wenn Sie es entfernen lassen (String o), funktioniert das nicht mehr.