Core Java

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>(); 
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.

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.


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<>();
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.

Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button