Cédric Beust, in an interesting review of new Java language features, notes something that most people who have used Generics will have seen. You very often end up declaring variables something like this:

Map<String, List<Account>> accounts =
  new HashMap<String, List<Account>>();

The repetition is annoying and error-prone. Cédric writes:

Not only is the code significantly harder to read, but it fails to obey the DRY principle ("Don't repeat yourself"). What if I need to change the value type of this map from List<Account> to Collection<Account>? I need to replace all these statements everywhere in my code. While IDE refactoring will help, it's still an awful lot of code for a modification of this kind that hardly impacts the semantics of this code.

Fortunately, there is a simple way to define Util.newMap() such that you can write:

Map<String, List<Account>> accounts = Util.newMap();

The definition is simply:

public static <K,V> Map<K,V> newMap() {
    return new HashMap<K,V>();
}

An additional advantage is that you don't have to write the ugly concrete type HashMap in your code.

The compiler can figure out what kind of Map you want if you assign to a Map variable, though not if you pass Util.newMap() as a parameter to a method. Then you might need a temporary variable.

Obviously you can do the same thing for other generic types like List and Set.

I've logged this as a Request For Enhancement on java.util.Collections.

List<String> stringList = new ArrayList();

List<String> stringList = new ArrayList<>();

   HashMap<String, List<Account>> accounts = new HashMap();
 
   let a1 = accounts.get("Cedric");
   ?List<Account> a2 = accounts.get("Cedric");