Question

I watched the Oracle OTN Virtual Event: Java SE and JavaFX 2.0 (28 Feb 2012) and while talking about the new diamond operator (that Map<String, List<String>> myMap = new HashMap<>(); thing) the speaker mentioned that it was not as simpleto implement than one might think, as it is not a simple token replacement.

My question is why? Why can’t be this implemented as simply taking the string from the variable’s declaration and put it into the diamond operator?

Answer 1

I didn’t implement it either, so I can only guess.

But usually the reason these things are more complex than they seem is that first inspection only looks at the most common (or most publicized) use case. In this case it’s the one you mentioned. In theory that should be easy to specify exactly and it should be rather easy to implement in a compiler.

However, the diamond operator (which is not technically a operator, by the way) can be used in different ways as well:

someMethodWithGenericArguments(new HashMap<>());
new SomeGenericClass(new HashMap<>());
T foo = new SomethingRelatedToT<>(); // where T is a generic type parameter

In those cases a simple token replacement obviously no longer works, you need actual type inference involving real type analysis (i.e. it’s on an entirely different abstraction level as a simple token replacement would be).