Чому колекції Java не видаляють загальні методи?

Чому Collection.remove (Object o) не є загальним?

Здається, Collection<E>могло бboolean remove(E o);

Потім, коли ви випадково намагаєтесь видалити (наприклад) Set<String>замість кожної окремої рядки з а Collection<String>, пізніше це буде помилка часу компіляції, а не проблема налагодження.

Джош Блох та Білл П'ю посилаються на цю проблему в Java Puzzlers IV: The Phantom Reference Menace, Attack of the Clone та Revenge of the Shift .

Джош Блох каже (6:41), що вони намагалися узагальнити метод отримання Map, видалити метод та деякі інші, але "це просто не вийшло".

Занадто багато розумних програм, які неможливо було б узагальнити, якщо дозволити лише загальний тип колекції як тип параметра. Приклад , наведений їм є перетин Listз Numberс і Listна Longс.

remove()( Mapяк і в Collection) не є загальним, тому що ви повинні мати можливість передавати будь-який тип об'єкта remove(). Видалений об’єкт не повинен бути того ж типу, що і об'єкт, до якого ви передаєте remove(); потрібно лише, щоб вони були рівними. З специфікації remove(), remove(o)видаляє об'єкт eтакий, який (o==null ? e==null : o.equals(e))є true. Зауважте, що нічого не потрібно oі eбути того ж типу. Це випливає з того факту, що equals()метод приймає в якості Objectпараметра не такий же тип, як об’єкт.

Хоча, можливо, правдою є те, що багато класів equals()визначають так, що його об'єкти можуть бути рівними лише об'єктам власного класу, але це, звичайно, не завжди. Наприклад, специфікація List.equals()говорить про те, що два об'єкти List рівні, якщо вони обидва Списки і мають однаковий вміст, навіть якщо вони різні реалізації List. Так що, повертаючись до прикладу в цьому питанні, можна мати Map<ArrayList, Something>і для мене , щоб зателефонувати remove()з в LinkedListякості аргументу, і він повинен видалити ключ , який представляє собою список з тим же вмістом. Це було б неможливо, якби remove()були загальними та обмежили його тип аргументу.

Оскільки, якщо ваш параметр типу є загальним символом, ви не можете використовувати загальний метод видалення.

Здається, я згадую, що я стикався з цим питанням методом get (Object) Map. Метод get в цьому випадку не є загальним, хоча слід обґрунтовано очікувати, що він буде переданий об'єктом того ж типу, що і параметр першого типу. Я зрозумів, що якщо ви проходите навколо Карт із підстановкою як перший параметр типу, тоді ви не зможете вилучити елемент із Мапи за допомогою цього методу, якщо цей аргумент був загальним. Аргументи wildcard насправді не можуть бути задоволені, оскільки компілятор не може гарантувати правильність типу. Я припускаю, що причина додавання є загальною в тому, що ви повинні гарантувати правильність типу перед тим, як додати його до колекції. Однак при видаленні об’єкта, якщо тип неправильний, він все одно не відповідатиме.

Я, мабуть, не дуже добре пояснив це, але мені це здається досить логічним.

Окрім інших відповідей, є ще одна причина, чому метод повинен приймати an 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, немає жодних проблем сказати, чи з’являється він у колекції - просто відповідайте «ні, це не так». Колекція "типу пошуку" якогось типу повинна мати можливість осмислено приймати посилання на будь-який супертип і визначати, чи існує об'єкт у колекції. Якщо посилання на об'єкт, що передається, має непов'язаний тип, колекція не може його містити, тому запит у певному сенсі не має сенсу (він завжди відповідає "ні"). Тим не менш, оскільки немає жодного способу обмежити параметри підтипами або супертипами, найрезультативніше просто прийняти будь-який тип і відповісти "ні" на будь-які об'єкти, тип яких не пов'язаний з типом колекції.

Я завжди вважав, що це тому, що Remove () не має підстав піклуватися про те, який тип об'єкта ви йому надаєте. Досить просто, незалежно, перевірити, чи є цей об'єкт одним із тих, що містить колекція, оскільки він може називати рівним () будь-що. Необхідно перевірити тип на add (), щоб переконатися, що він містить лише об'єкти цього типу.

Це був компроміс. Обидва підходи мають свою перевагу:

• remove(Object o)
  • є більш гнучким. Наприклад, це дозволяє повторити список номерів та видалити їх із списку довгих.
  • код, який використовує цю гнучкість, може бути легше узагальнений
• remove(E e) приносить більшу безпеку типу тим, що більшість програм хоче робити, виявляючи непомітні помилки під час компіляції, як помилково намагаючись видалити ціле число зі списку шортів.

Зрозуміла зворотна сумісність завжди була головною метою при розробці API Java, тому було вибрано видалення (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 */
}

Тому що він би порушив існуючий (до Java5) код. наприклад,

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

Тепер ви можете сказати, що наведений вище код невірний, але припустимо, що o походив з неоднорідного набору об'єктів (тобто він містив рядки, число, об'єкти тощо). Ви хочете видалити всі збіги, що було законним, оскільки видалення просто ігнорувало б рядки, оскільки вони були нерівними. Але якщо ви змусите його видалити (String o), це більше не працює.