TypeErasure in Java

The concept of Generic has been introduced in the Java language in order to facilitate tighter checks of types at the compile time and to support generic programming. In order to implement generics, the compiler of Java applies the type erasure to:

Replacing all parameters type in the generic types with the bounds or Object when the type of the parameters is not bounded. The generated bytecode, hence, only contains the ordinary methods, interfaces, and classes.
Inserting the type casts if required in order to support the type safety.
Generating the bridge methods for preserving polymorphism in generic types that are extended.

Generally, generic code that is compiled just utilizes the java.lang.Object whenever one talks about P (or some different type parameter) - and there is some information (metadata), which tells the Java compiler that it is a generic type. Whenever one compiles the code against the method or generic type, the Java compiler deciphers what the person really means (that is, the compiler finds out the type argument for P) and validates at the compile-time that one is doing the correct thing or not. However, the code that is emitted again does talk in terms of the java.lang.Object - the Java compiler produces the extra casts where needed. At the execution time, a List and a List are the same. The Java compiler erases the extra type information.

// Here, P is getting bounded by the Object i.e., the java.lang.Object
public class TypeErasure<P> 
{
// Here, P gets replaced by the default, 
// that is the Object
P object;
// constructor of the class
TypeErasure(P o)
{
object = o;
}
// retrieving the object
P getObject()
{
return object;
}
}

After the compilation, the type parameter P is replaced by the default Object. Observe the following program.

// Here, P is getting bounded by the Object i.e., the java.lang.Object
public class TypeErasure 
{
// Here, P gets replaced by the default, 
// that is the Object
Object object;
// constructor of the class
TypeErasure(Object o)
{
object = o;
}
// retrieving the object
Object getObject()
{
return object;
}
}

Let's take another example, where the type parameter P extends the java.lang.String class.

// Here, P is getting bounded by the Object, i.e., the java.lang.String
public class TypeErasure1 <P extends String> 
{
// Here, P gets replaced by the String 
// that is the Object
P s;
// constructor of the class
TypeErasure1(P o)
{
s = o;
}
// retrieving the object
Object getObject()
{
return s;
}
}

After the compilation, we get

// Here, P is getting bounded by the Object, i.e., the java.lang.String
public class TypeErasure1 
{
// Here, P gets replaced by the String 
// that is the Object
String s;
// constructor of the class
TypeErasure1(String o)
{
s = o;
}
// retrieving the object
Object getObject()
{
return s;
}
}

Implementation of TypeErasure

Let's see an example of the implementation of TypeErasure.

FileName: TypeErasure2.java

// important import statements
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class TypeErasure2
{
public static void main(String args[])
{
// creating a list for storing the stings
List<String> lst = new ArrayList<String>();
// adding strings to the list
lst.add("Hello");
lst.add("World");
Iterator<String> itr = lst.iterator();
// iterating through the elements
// of the list
while (itr.hasNext()) 
{
String str = itr.next();
System.out.println(str);
}
}
}

Output:

Hello
World

Explanation: Here, when the code is compiled, no warning is issued by the compiler. It is due to Type Erasure.

Now, observe the following program.

FileName: TypeErasure3.java

// important import statements
import java.util.*;
import java.io.PrintStream;
public class TypeErasure3
{
// constructor of the class
public TypeErasure3()
{
}
// main method
public static void main(String args[])
{
List list = new ArrayList();
list.add("Hello");
list.add("World");
String s;
for (Iterator iter = list.iterator(); iter.hasNext();
System.out.println(s))
s = (String)iter.next();
}
}

When we compile the above program using the javac command, we get the following warning. It is because of the type erasure as it is not mentioned in the program about the type of list that is being used.