Який сенс алмазного оператора (<>) у Java 7?

Діамантовий оператор java 7 дозволяє такий код:

List<String> list = new LinkedList<>();

Однак на Java 5/6 я можу просто написати:

List<String> list = new LinkedList();

Моє розуміння стирання типу - це те саме. (Узагальнений варіант все одно видаляється під час виконання).

Навіщо взагалі турбуватися з діамантом? Які нові функціональні можливості / типи безпеки це дозволяє? Якщо він не дає ніяких нових функціональних можливостей, чому вони згадують його як особливість? Чи моє розуміння цього поняття хибно?

Випуск с

List<String> list = new LinkedList();

це те, що в лівій частині ви використовуєте загальний тип, List<String>де в правій частині ви використовуєте необроблений тип LinkedList. Сировинні типи в Java фактично існують лише для сумісності з кодом попереднього генерику і ніколи не повинні використовуватися в новому коді, якщо ви абсолютно не повинні.

Тепер, якщо у Java були дженерики з самого початку і не було таких типів, як, наприклад LinkedList, спочатку створені до того, як у них були дженерики, можливо, це могло б зробити так, що конструктор для загального типу автоматично виводить параметри свого типу зліва -ручна сторона завдання, якщо це можливо. Але це не відбулося, і він повинен по-різному ставитися до вихідних і загальних типів для зворотної сумісності. Це залишає для них необхідність зробити дещо інший , але не менш зручний спосіб декларування нового екземпляра родового об'єкта без необхідності повторювати його параметри типу ... оператор алмазу.

Що стосується вашого оригінального прикладу List<String> list = new LinkedList(), компілятор генерує попередження для цього завдання, оскільки він повинен. Врахуйте це:

List<String> strings = ... // some list that contains some strings

// Totally legal since you used the raw type and lost all type checking!
List<Integer> integers = new LinkedList(strings);

Загальна версія існує для захисту часу компіляції від неправильної дії. У наведеному вище прикладі використання сировинного типу означає, що ви не отримаєте цього захисту та отримаєте помилку під час виконання. Ось чому не слід використовувати сировинні типи.

// Not legal since the right side is actually generic!
List<Integer> integers = new LinkedList<>(strings);

Однак алмазний оператор дозволяє правою частиною завдання визначити справжній загальний екземпляр з тими ж параметрами типу, що і лівий ... без необхідності вводити ці параметри знову. Це дозволяє зберегти безпеку дженериків майже з тими ж зусиллями, як і використання сировинного типу.

Я думаю, що головне, що потрібно зрозуміти, - це те, що сировинні типи (без <>) не можна трактувати так само, як загальні типи. Коли ви декларуєте вихідний тип, ви не отримуєте жодної переваги та перевірки типу генеричних даних. Ви також повинні мати на увазі, що дженерики є частиною загальної мети мови Java ... вони не стосуються лише no-arg конструкторів Collections!

Ваше розуміння є дефектом. Діамантовий оператор - це приємна особливість, оскільки не потрібно повторювати себе. Є сенс визначити тип один раз, коли ви декларуєте тип, але просто не має сенсу визначати його знову з правого боку. Принцип DRY

Тепер пояснимо всі нечітки щодо визначення типів. Ви маєте рацію, що тип видалено під час виконання, але як тільки ви захочете отримати щось із списку з визначенням типу, ви отримаєте його назад як тип, який ви визначили при оголошенні списку, інакше він втратить усі конкретні функції та матиме лише Особливості об'єкта, за винятком випадків, коли ви передали отриманий об'єкт оригінальному типу, який іноді може бути дуже складним і призводити до класу ClassCastException.

Використовуючи List<String> list = new LinkedList(), ви отримаєте попередження про вихідний тип.

Цей рядок викликає попередження [невірно]:

List<String> list = new LinkedList();

Отже, питання трансформується: чому попередження попередженого режиму не придушується автоматично лише у випадку створення нової колекції?

Я думаю, було б набагато складніше завдання, ніж додавання <> функції.

UPD : Я також думаю, що було б безладдя, якби юридично було використовувати сировинні типи "лише для кількох речей".

Теоретично оператор алмазів дозволяє писати більш компактний (і читабельний) код, зберігаючи аргументи повторного типу. На практиці це просто дві заплутані характеристики, які нічого не дають. Чому?

1. Жоден здоровий програміст не використовує вихідні типи в новому коді. Таким чином, компілятор може просто припустити, що, не записуючи аргументів типу, ви хочете, щоб вони їх зробили.
2. Діамантовий оператор не надає інформації про тип, він просто каже компілятору, "це буде добре". Тож, опустивши його, ви можете не нашкодити. У будь-якому місці, де алмазний оператор легальний, компілятор може "зробити висновок".

IMHO, мати чіткий і простий спосіб позначити джерело як Java 7 було б корисніше, ніж вигадувати такі дивні речі. У такому маркованому коді необроблені типи можуть бути заборонені, нічого не втрачаючи.

До речі, я не думаю, що це потрібно робити за допомогою перемикача компіляції. Версія Java для програмного файлу є атрибутом файлу, взагалі немає опції. Використовуючи щось настільки тривіальне, як

package 7 com.example;

це може зрозуміти (ви можете віддати перевагу щось більш складне, включаючи одне або декілька вигадливих ключових слів). Це навіть дозволило б без проблем збирати джерела, написані для різних версій Java. Це дозволить ввести нові ключові слова (наприклад, "модуль") або видалити деякі застарілі функції (кілька непублічних невкладених класів в одному файлі чи будь-якому іншому), не втрачаючи сумісності.

Коли ви пишете List<String> list = new LinkedList();, компілятор видає попередження "без перевірки". Ви можете ігнорувати це, але якщо ви ігнорували ці попередження, ви також можете пропустити попередження, яке повідомляє вас про реальну проблему безпеки.

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

Усі сказані в інших відповідях є дійсними, але випадки використання не є повністю дійсними IMHO. Якщо хтось перевіряє Guava, і особливо речі, пов'язані з колекціями, те саме було зроблено зі статичними методами. Наприклад, Lists.newArrayList (), що дозволяє писати

List<String> names = Lists.newArrayList();

або зі статичним імпортом

import static com.google.common.collect.Lists.*;
...
List<String> names = newArrayList();
List<String> names = newArrayList("one", "two", "three");

У Guava є такі дуже потужні функції, як ця, і я насправді не можу придумати багато можливостей для <>.

Було б корисніше, якби вони зробили поведінку оператора алмазу за замовчуванням, тобто тип виводили з лівого боку виразу або якщо тип лівої сторони було виведено з правого боку. Останнє - це те, що відбувається у Scala.

Сенс для оператора алмазів - просто зменшити введення коду при оголошенні загальних типів. Це ніяк не впливає на час виконання.

Єдина відмінність, якщо ви вкажете в Java 5 і 6,

List<String> list = new ArrayList();

полягає в тому, що вам потрібно вказати @SuppressWarnings("unchecked")значення list(інакше ви отримаєте попередження про неперевірену передачу). Я розумію, що алмазовий оператор намагається полегшити розробку. Це не має нічого спільного з виконанням дженериків.