Что такое даймонд оператор java

В чем смысл алмазного оператора (<>) в Java 7?

Оператор diamond в Java 7 разрешает код, подобный следующему:

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

Я понимаю, что стирание типов это то же самое. (Универсальный в любом случае удаляется во время выполнения).

Зачем вообще беспокоиться о бриллианте? Какие новые функциональные возможности/безопасность типов это позволяет? Если это не дает никакой новой функциональности, почему они упоминают это как функцию? Мое понимание этой концепции неверно?

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

Теперь объясним весь паз об определении типов. Вы правы в том, что тип удаляется во время выполнения, но как только вы захотите извлечь что-то из списка с определением типа, вы получите его обратно как тип, который вы определили при объявлении списка, иначе он потеряет все специфические функции и будет иметь только Возможности объекта, за исключением случаев, когда вы приводите извлеченный объект к его исходному типу, который иногда может быть очень сложным и привести к исключению ClassCastException.

Использование List list = new LinkedList() вы получите предупреждения rawtype.

Эта строка вызывает предупреждение [unchecked]:

Итак, вопрос трансформируется: почему предупреждение [unchecked] не подавляется автоматически только для случая, когда создается новая коллекция?

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

Теоретически, оператор diamond позволяет писать более компактный (и читаемый) код, сохраняя аргументы повторяющегося типа. На практике это только два запутанных символа, которые больше ничего не дают. Зачем?

ИМХО, наличие ясного и простого способа пометить источник как Java 7 было бы более полезным, чем придумывать такие странные вещи. В таком маркированном коде необработанные типы могут быть запрещены, не теряя ничего.

Кстати, я не думаю, что это должно быть сделано с помощью переключателя компиляции. Версия программного обеспечения Java является атрибутом файла, никакой опции вообще нет. Используя что-то тривиальное, как

может прояснить это (вы можете предпочесть что-то более сложное, включая одно или несколько необычных ключевых слов). Это даже позволило бы без проблем скомпилировать исходные тексты, написанные для разных версий Java. Это позволило бы вводить новые ключевые слова (например, «модуль») или отбрасывать некоторые устаревшие функции (несколько непубличных не вложенных классов в одном файле или что-либо еще) без потери какой-либо совместимости.

Итак, лучше написать код, который не генерирует лишних предупреждений, а оператор Diamond позволяет делать это удобным способом без лишних повторов.

Все сказанное в других ответах является действительным, но варианты использования не полностью действительны ИМХО. Если кто-то проверяет Guava и особенно вещи, связанные с коллекциями, то же самое было сделано со статическими методами. Например. Lists.newArrayList () который позволяет писать

или со статическим импортом

У Гуавы есть и другие очень мощные функции, подобные этой, и я на самом деле не могу придумать много вариантов использования <>.

Было бы более полезно, если бы они использовали поведение по умолчанию для оператора diamond, то есть тип определялся с левой стороны выражения или если тип левой стороны был выведен с правой стороны. Последнее то, что происходит в Scala.

Единственное отличие, если вы укажете в Java 5 и 6,

является то, что вы должны указать @SuppressWarnings(«unchecked») для list (в противном случае вы получите непроверенное предупреждение о приведении). Насколько я понимаю, оператор бриллиантов пытается облегчить разработку. Он не имеет ничего общего с исполнением обобщений во время выполнения.

Источник

В чем смысл оператора diamond в Java 7?

оператор diamond в java 7 позволяет использовать следующий код:

однако в Java 5/6, я могу просто написать:

мое понимание стирания типа заключается в том, что они точно такие же. (В любом случае generic удаляется во время выполнения).

зачем вообще возиться с бриллиантом? Какие новые функции / тип безопасности это позволяет? Если он не дает никаких новых функций, почему они упоминают его как функцию? Насколько я это понимаю? концепция ошибочна?

7 ответов

дженерики существуют для обеспечения защиты времени компиляции от неправильных действий. В приведенном выше примере использование типа raw означает, что вы не получаете эту защиту и получите ошибку во время выполнения. Вот почему вы не должны использовать сырые типы.

Я думаю, что главное понять, что сырые типы (без <> ) нельзя рассматривать так же, как и универсальные типы. Когда вы объявляете необработанный тип, вы не получаете ни одного из преимущества и проверка типа дженериков. Вы также должны иметь в виду, что дженерики являются частью общего назначения языка Java. они не просто применяются к конструкторам no-arg Collection s!

ваше понимание слегка искажено. Алмазный оператор-хорошая функция, так как вам не нужно повторяться. Имеет смысл определить тип один раз, когда вы объявляете тип, но просто не имеет смысла определять его снова с правой стороны. Сухой принцип.

теперь, чтобы объяснить все пух об определении типов. Вы правы, что тип удаляется во время выполнения, но как только вы хотите получить что-то из списка с определением типа, вы получаете его обратно как тип вы определили при объявлении списка, иначе он потеряет все конкретные функции и будет иметь только объекты, за исключением случаев, когда вы приведете извлеченный объект к исходному типу, который иногда может быть очень сложным и привести к ClassCastException.

С помощью List list = new LinkedList() получите предупреждения rawtype.

эта строка вызывает предупреждение [unchecked]:

Итак, вопрос трансформируется: почему предупреждение [unchecked] не подавляется автоматически только в случае создания новой коллекции?

Я думаю, это было бы гораздо более сложной задачей, чем добавление <> характеристика.

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

теоретически оператор diamond позволяет писать более компактный (и читаемый) код, сохраняя повторяющиеся аргументы типа. На практике это просто два запутанных символа, которые больше ничего не дают. Почему?

IMHO, имея ясный и простой способ пометить источник как Java 7, было бы более полезно, чем изобретать такие странные вещи. В таком отмеченном коде необработанные типы могут быть запрещены без потери чего-либо.

кстати., Я не думаю, что это следует делать с помощью переключателя компиляции. Java-версия файла программы является атрибутом файла, без опции вообще. Используя что-то тривиальное, как

может прояснить (вы можете предпочесть что-то более сложное, включая одно или несколько причудливых ключевых слов). Это даже позволило бы без проблем компилировать источники, написанные для разных версий Java. Это позволило бы вводить новые ключевые слова (например, «модуль») или отбрасывать некоторые устаревшие функции (несколько непубличных не вложенных классов в одном файле или что-либо еще) без потери совместимости.

Итак, лучше написать код, который не генерирует дополнительных предупреждений, а diamond operator позволяет сделать это удобным способом без ненужного повторения.

все сказанное в других ответах допустимо, но варианты использования не являются полностью допустимыми IMHO. Если один проверяет гуавы и особенно связанные с коллекциями вещи, то же самое было сделано со статическими методами. Е. Г. списки.newArrayList () что позволяет писать

или со статическим импортом

Это было бы более полезно, если бы они пошли на то, чтобы сделать поведение оператора diamond по умолчанию, то есть тип выводится с левой стороны выражения или если тип левой стороны выводился с правой стороны. Последнее происходит в Scala.

пункт для оператора Диаманта просто уменьшить печатать кода объявляя родовые типы. Это не имеет никакого влияния на время выполнения вообще.

единственная разница, если вы укажете в Java 5 и 6,

— Это, что вы должны указать @SuppressWarnings(«unchecked») до list (в противном случае вы получите непроверенное предупреждение о приведении). Насколько я понимаю, алмазный оператор пытается облегчить разработку. Ему нечего делать на выполнения дженериков в все.

Источник

Diamond Operator in Java

Sep 18, 2018 · 2 min read

Diamond operator aka diamond syntax was introduced in Java 7 as a new feature. Purpose of the diamond operator is to simplify the use of generics when creating an object.

It avoids unchecked warnings in a program as well as reducing generic verbosity by not requiring explicit duplicate specification of parameter types.

Raw Types prior to Java 5

Before Java 5, the collections API supports only raw types. There was no way for type arguments be parameterized when constructing a collection.

The above code runs just fine, but suppose you also have the following:

Now we run i n to trouble at run-time, because the list contains something that isn’t an instanceof String.

Presumably, if you want names to contain only String, you could perhaps still use a raw type and manually check every add yourself, and then manually cast to String every item from names.

Generics from Java 5

Generics were introduced — which allowed us to parameterize the type arguments for classes,

Raw types refer to using a generic type without specifying a type parameter. For example, List is a raw type, while List is a parameterized type.

When generics were introduced in JDK 1.5, raw types were retained only to maintain backwards compatibility with older versions of Java.

At this point, we have to specify the parameterized type in the constructor, which can be somewhat unreadable:

Even though the compiler still allows us to use raw types in the constructor,

it will prompt us with a warning message:

ArrayList is a raw type. References to generic type ArrayList should be parameterized

Diamond Operator from Java 7

With Java 7, the diamond operator makes this shorter and simpler. It also adds type inference and reduces the verbosity in the assignments — when using generics:

It becomes even more useful with more complex data types, such as a List of Map objects as follows:

Simply put, the diamond operator adds the type inference feature to the compiler and reduces the verbosity in the assignments introduced with generics.

Generics allow us to keep the safety of generics with almost the same effort as using the raw type.

Источник

Дельфин, монета и бриллиантовый оператор.

Релиз Java 7 должен выйти 28 Июля.
В связи с этой знаменательно датой, я наконец-то решил посмотреть, что нас всех ждет. Поскольку в последнее время в основном занимаюсь Scala, то на новые языковые фичи в Java не обращал серьезного внимания (только на тусовках java-программистов, плюс поглядывал что пишут в разных блогах жависты).

Технических новшеств очень много. Среди них самое интересное место занимает так называемый «Проект Монета (Project Coin)».

Он содержит в себе небольшие (конечно с их точки зрения) изменения в языке:

— Strings in switch
— Binary integral literals and underscores in numeric literals
— Multi-catch and more precise rethrow
— Improved type inference for generic instance creation (diamond)
— try-with-resources statement
— Simplified varargs method invocation

В этом посте я наверно не смогу написать про все фичи, пока хотел обратить внимание на некоторые интересные на мой взгляд моменты.

Improved type inference for generic instance creation (diamond)

Это так называемый оператор diamond (бриллиант, алмаз). Думаю называется так, потому что чем-то похож на камень: <>.

В качестве примера часто приводят такой код:

// Java 7 List a = new ArrayList<>(); // до Java 7 List b= new ArrayList ();

Это конечно очень красиво, т.к. мы смогли уменьшить размер кода. Но возникает вопрос, чем это лучше, если раньше можно сделать еще проще? Вот так:

// в Java 7 List a = new ArrayList<>(); // до Java 7 List b = new ArrayList();

Понятно, что мы здесь используем сырой тип (raw types) и поэтому некоторым программистам по «морально-этическим» соображениям такой код не нравится.
Хотя один java-программист даже не поленился и сравнил полученный байт-код: jdk-7-diamond-operator.
Он показал на примере, что никакой разницы от использования бриллианта в компилируемом байт-коде нет, т.к. весь этот сахар при компиляции пропадает.

Мне кажется, что более реальная польза, может быть показана в следующем примере:

List a = new ArrayList<>(); // Такой прокатит, хотя и ошибочный, что плохо. List b = new ArrayList(a); // Такой уже отрубится компилятором, что хорошо. List c = new ArrayList<>(a);

Таким образом, наш бриллиантик автоматически выведет тип. Затем поймет, что у нас должен быть конструктор от списка чисел. Потом компилятор понимает, что нам вместо этого подают список строк и создаст ошибку компиляции.

try-with-resource

Появился новый интерфейс AutoCloseable. Причем не где-то там в io (как Closeable), а в самом java.lang!

Этот интерфейс был подсунут в иерархию над Closeable (Closeable extends AutoCloseable).
Таким образом, автоматически все потоки (_Stream) и читатели/писатели(Reader/Writer) становятся также AutoCloseable.
В AutoCloseable есть один метод void close() throws Exception.

Идея заключается в том, что если указать AutoCloseable переменные (в терминах Java 7 они называются ресурсы) в скобочках после try, то они всегда автоматически закроются при выходе из try блока.

В качестве примера как правило приводят обычно что-то вроде:

Источник

Diamond operator for Anonymous Inner Class with Examples in Java

Diamond Operator: Diamond operator was introduced in Java 7 as a new feature.The main purpose of the diamond operator is to simplify the use of generics when creating an object. It avoids unchecked warnings in a program and makes the program more readable. The diamond operator could not be used with Anonymous inner classes in JDK 7. In JDK 9, it can be used with the anonymous class as well to simplify code and improves readability. Before JDK 7, we have to create an object with Generic type on both side of the expression like:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

When Diamond operator was introduced in Java 7, we can create the object without mentioning generic type on right side of expression like:

Problem with Diamond Operator in JDK 7?

With the help of Diamond operator, we can create an object without mentioning the generic type on the right hand side of the expression. But the problem is it will only work with normal classes. Suppose you want to use the diamond operator for anonymous inner class then compiler will throw error message like below:

Источник