Type Inference from Java 7

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?

List<string> names = new ArrayList<string>();
Map<string, Object> objectMap = new HashMap<string, Object>(); 

Something like this.

List<string> names = new ArrayList();
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.

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:

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:

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:

class Demo {
void printStudentNames(List<string> names) {
for(String name:names) {
System.out.println("String name:"+name);
}
}

public static void main(String[] args) {
Demo demo = new Demo();
demo.printStudentNames(new ArrayList<>());   // It saved typing here in a method call too.
List<string> names = new ArrayList<>();
printStudentNames(names);
List<string> copyOfNames = new ArrayList<>(names);  // It saved typing here in a copy contructor invocation too.
}
}

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

Something like this

Class Tree<t> {

public void demoFunction(List<t> objList) {
List<t> copyOfNames = new ArrayList<t>(objList);   //This is not gonna work.
}
}

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

Reference: Why do we need Type Inference from Java 7? from our JCG partner Saurab Parakh at the Coding is Cool blog.