Maurizio Cimadamore has just push a patch that enable to use diamond syntax to instantiate a generics.
The diamond syntax is one of the changes introduced by the coin project and is the first one introduced in jdk7 repository.

The diamond syntax allows to instantiate a generic type without specify the type argument, the compiler will infer them using the context. In the example above, you can note that the list or the map are instantiated without providing things between the brackets. This change doesn't turn Java into something really different but, in my opinion, it really improves the readability.

Just one line about the algorithm used, the constructor inference syntax uses it own algorithm instead of relying on the one used to infer method type argument. I think this is not a good idea because we have now two different inference algorithms but Maurizio thinks that this new algorithm better fit with the constructor inference problem and he is more expert than me :)

  import java.util.*;

  public class DiamondTest {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          Collections.addAll(list, args);

          Map<Integer, List<String>> map = new HashMap<>();
          for(String s:list) {
              int length = s.length();
              List<String> l = map.get(length);
              if (l == null) {
                  l = new ArrayList<>();
                  map.put(length, l);
              }
              l.add(s);
          }
          System.out.println(map);
      }
  }

If, like me, you can't wait the next binary build. I have prepared a jar tools-diamond.jar containing javac compiled with the diamond patch. It requires a recent jdk7 beta.

To compile :

  /usr/jdk/jdk1.7.0/bin/java -cp tools-diamond.jar:. com.sun.tools.javac.Main DiamondTest.java

And to execute :

$ /usr/jdk/jdk1.7.0/bin/java DiamondTest foo bar foobar
{3=[foo, bar], 6=[foobar]}

Cheers,
Rémi