What is Diamond operator in java 7 , and what is the use of this , explanation with the simple example

Every good programmer likes to write a concise but effective and optimized code. Type Inference is a way introduced in JDK 7 which will surely give you benefits of less typing. Its been a long time that you have using the java code in following manner.

But have you ever thought of code duplication while initializing the specific implementation of Collections? Why there is a need to write the parameters two times during an intialization?

1	List<string> names = new ArrayList<string>();

2	Map<string, Object> objectMap = new HashMap<string, Object>();

Now most of you would be thinking of initializing as a raw types as you had been doing in previous JDK version.

Something like this. 

1	List<string> names = new ArrayList();

2	Map<string, object=""> objectMap = new HashMap();

So whats new in JDK 7? What benefits you will have from the new feature? 
So first we need to understand the difference between raw type and generic type intialization. 

A statements like this ensures that the implementation will contain the same parameter as specified during initialization. 

1	List<string> names = new ArrayList<string>();

In the following example, the compiler generates an unchecked conversion warning because the HashMap() constructor refers to the HashMap raw type, not the Map<String, List<String>> type: 

1	Map<String, List<String>> myMap = new HashMap(); // unchecked conversion warning

Diamond Operator
  
Okay Now I will introduce the new feature of JDK 7. 
So we have something called Diamond operator in JDK 7 which reduces your extra typing while initialization. 

Syntax: 

1	List<string> names = new ArrayList<>();

So it not only reduces your code but also ensures the type checking. 
Here is a more clear example explaining the benefits of type inference. 

Advanced Example: 

01	class Demo {

02	void printStudentNames(List<string> names) {

03	for(String name:names) {

04	System.out.println("String name:"+name);

05

}

06

}

07

08	public static void main(String[] args) {

09	Demo demo = new Demo();

10	demo.printStudentNames(new ArrayList<>());   // It saved typing here in a method call too.

11	List<string> names = new ArrayList<>();

12	printStudentNames(names);

13	List<string> copyOfNames = new ArrayList<>(names);  // It saved typing here in a copy contructor invocation too.

14

}

15

}

Now what are its limitations? 
It won't work in the case you use wildcards. 

Something like this 

1	Class Tree<t> {

2

3	public void demoFunction(List<t> objList) {

4	List<t> copyOfNames = new ArrayList<t>(objList);   //This is not gonna work.

5

}

6

}

In the above case the arguments passed in the copy constructor should be Collection<? extends T> 
So it wont accept the above inference type.