Vlákno názorů k článku Novinky v JDK 7 aneb mírný pokrok v mezích zákona (2) od Petr Balat - No promiňte, ale jak koukám na tu diskuzi...

No promiňte, ale jak koukám na tu diskuzi tak si nikdo i včetně autora článku nikdo nevšiml (tragikomedie je že to neví i lidi z coinu:-( ) že v části 5. Je operátor <> skutečně nezbytný a/nebo dostatečně obecný?
má chybu a to takovou že lze zapsat... viz jednoduchý test:

//kompilováno pod jdk6, javac kompilátor pouze upozorní na potenciální //unsafe operaci
public class CollectionTest {

@Test
public void testType() {
List<String> list = new ArrayList();
List<List<String>> list2 = new ArrayList();
List<List<Lis­t<String>>> list3 = new ArrayList();
Map<String, Collection<In­teger>> map = new LinkedHashMap();

//list.add(new Integer(1));//nejde zkompilovat
list.add(Strin­g.valueOf("he­llo"));//toto jo

//list2.add(new Integer(2));//nejde zkompilovat
list2.add(new ArrayList());//toh­le jo ! všimně te si že se nekontroluje typ !!!

List beztypovyList = list;
beztypovyList­.add(new Integer(3)); //tohle projde i s tím pitomým diamantem!!!

//tohle projde
for (Object object : beztypovyList) {
System.out.prin­tln(object);
}

//tohle NEprojde ale spadne ! a spadne to i s tím pitomým diamantem!!!
for (String object : list) { //java.lang.Clas­sCastException: java.lang.Integer cannot be cast to java.lang.String
System.out.prin­tln(object);
}
}
}

přesně nevylepší, proto také nevím jaký má důvod

Rozdíl je ve varování.

List list = new ArrayList();

se přeloží, ale s varováním.

List list = new ArrayList<>();

se přeloží jako

List list = new ArrayList();

(parametrické typy z levé strany se okopírují doprava), tedy bez varování.

Ano to jsem psal Filipe, ale to mi pořád přijde zbytečné přidávat konstrukci navíc (lze udělat pouze u vytvoření nového objektu) místo aby u vytvoření nového objektu zrušili to upozornění! ;-)
Pokud si vygeneruješ class soubor tak v obou případech bude stejný takže se se to opravdu redukuje na výběr mezi zrušení upozornění nebo přidávat novou konstrukci

tak jediný důvod který jsem našel je že pokud

List<String> strings = new ArrayList();
strings.add("he­llo");

//přidělím při vytvoření nové kolekce

List<Integer> integers = new ArrayList(strings);
//tak dál už to je potenciálně nebezpečné ale pokud udělám

List<Integer> integers = new ArrayList<>(strin­gs);
//tak mi to kompilátor nedovolí