Java 1.5 Generics Tutorial: How Generics Inward Coffee Industrial Plant Amongst Event Of Collections, Best Practices, Gotchas

Java Generics Tutorial

Generics inwards Java is 1 of of import characteristic added inwards Java v along amongst Enum, autoboxing together with varargs, to supply compile fourth dimension type-safety. Generics is also considered to live 1 of the tough concepts to empathise inwards Java together with somewhat it’s truthful every bit well. I direct maintain read many articles on generics inwards Java, some of them are quite goodness together with detailed but I soundless felt that those are either likewise much technical or exhaustively detailed, hence I thought to write a uncomplicated yet informative article on Java generics to give a caput start to beginners without bothering their caput likewise much. In this Java generics tutorial, I volition embrace How Generics industrial plant inwards Java,  some mysterious wildcards inwards Generics together with some of import points almost Generic inwards Java. I volition essay explaining generics concept inwards uncomplicated words together with uncomplicated examples.

I thought almost writing on Java Generics when I completed my post on 10 Examples of Enum inwards Java. Since Enum together with Generics are introduced at the same fourth dimension inwards JDK 5, but it took a long fourth dimension to destination this post. Anyway, I am happy that it's finally out together with covers Generics inwards goodness detail. 

On a different note, If you lot similar to larn novel concepts yesteryear next books hence you lot should banking concern check Java Generics together with Collection, 1 of the best majority on Generics, which covers from basics to best practices.

What is Generics inwards Java

runtime which was quite frequent error inwards Java code, for those who doesn’t know what is type-safety at compile time, it’s simply a banking concern check yesteryear compiler that right Type is used inwards right house together with at that spot should non live whatever ClassCastException.

For example, HashSet of String volition alone incorporate String object together with if you lot essay to lay Integer or whatever other object, the compiler volition complain. Before Java v same code volition exceed compile fourth dimension banking concern check but volition neglect at runtime which is worse. Generics allows Java programmer to write to a greater extent than robust together with type-safe code. In my sentiment generics inwards Java is much overdue characteristic given popularity of Collection framework inwards coffee and its limitation simply about treatment type-safety.

Though Generics may human face rattling complex because of its mysterious angle bracketing <> and diverse wild cards on Java generics, but 1 time you lot empathise the role of Generics inwards Java or Why Generics is introduced inwards Java you lot volition live rattling comfortable together with dear writing code using Generics.

If you lot are a beginner together with non familiar amongst Generics I strongly advise you lot lay some fourth dimension together with empathise the Generics together with halt writing collection classes without Generics. It non alone saves you lot from mischievous ClassCastException but also gives you lot to a greater extent than readability together with deterministic conduct from code. In this Java Generics tutorial, nosotros volition run into some of import points simply about Generics together with Java together with volition revise some materials you lot may know.

If you lot similar to read almost generics hence you lot tin also banking concern check my other tutorials on generics e.g. 10 generics interview inquiry inwards Java and Difference betwixt bounded together with unbounded wildcards inwards Generics.

How Generics industrial plant inwards Java

This is a popular Java Generics interview question which comes to my hear piffling late, It didn't come upward when I root know almost generics inwards Java but a piece later, nonetheless I honour it quite useful to know almost how generics industrial plant inwards coffee behind the scene. The buzzing keyword is "Type Erasure", you lot guessed it right it’s the same matter nosotros used to inwards our schools for erasing our mistakes inwards writing or drawing :).

The Same matter is done yesteryear Java compiler, when it sees code  written using Generics it completely erases that code together with convert it into raw type i.e. code without Generics. All type related information is removed during erasing. So your ArrayList<Gold> becomes manifestly sometime ArrayList  prior to JDK 1.5, formal type parameters e.g. <K, V> or <E> gets replaced yesteryear either Object or Super Class of the Type.

Also, when the translated code does non direct maintain right type, the compiler inserts a type casting operator. This all done behind the scene hence you lot don't bespeak to worry almost what of import to us is that Java compiler guarantees type-safety together with flag whatever type-safety relate error during compilation.

In brusk Generics inwards Java is syntactic carbohydrate together with doesn’t shop whatever type related information at runtime. All type related information is erased yesteryear Type Erasure, this was the principal requirement piece developing Generics characteristic inwards lodge to reuse all Java code written without Generics.

Rules together with Examples of Generics inwards Java

Let’s run into some dominion of using Generics inwards Java on Collections, Type prophylactic degree together with type prophylactic methods amongst uncomplicated examples:

1) Parametrized type similar Set<T> is subtype of raw type Set together with you lot tin assign Set<T> to Set, next code is legal inwards Java:

Set setOfRawType = new HashSet<String>();
setOfRawType = new HashSet<Integer>();

2) Set<Object> is setOfAnyType, it tin shop String, Integer but you lot tin non assign setOfString or setOfInteger to setOfObject using Generics inwards Java.

Set<Object> setOfAnyType = new HashSet<Object>();
setOfAnyType.add("abc"); //legal
setOfAnyType.add(new Float(3.0f)); //legal - <Object> tin convey whatever type

3)Set<?> represents SetOfUnknownType together with you lot tin assign SetOfString or SetOfInteger to Set<?> every bit shown inwards below illustration of Generics :

Set<?> setOfUnknownType = new LinkedHashSet<String>();
setOfUnknownType = new LinkedHashSet<Integer>();

4)Parametrized Type also follow Inheritance at principal Type aeroplane way both HashSet<String> together with LinkedHashSet<String> are sub types of Set<String> together with legal yesteryear compiler every bit shown inwards next Generics illustration inwards Java :

Set<String> setOfString = new HashSet<String>(); //valid inwards Generics
setOfString = new LinkedHashSet<String>(); // Ok

But Inheritance on type parameter is non supported way Set<Object> volition non convey Set<String> every bit per next Generics code.

Set<Object> SetOfObject = new HashSet<String>(); //compiler error - incompatible type

5)Set<? extends Number> volition shop either Number or subtype of Number similar Integer, Float. This is an illustration of bounded wildcards inwards Generics

Set<? extends Number> setOfAllSubTypeOfNumber = new HashSet<Integer>(); //legal - Integer extends Number
setOfAllSubTypeOfNumber = new HashSet<Float>(); //legal - because Float extends Number

6)Set<? super TreeMap> is some other illustration of bounded wildcards, which volition shop instances of TreeMap or super degree of TreeMap. See next Generics illustration inwards Java :

Set<? super TreeMap> setOfAllSuperTypeOfTreeMap = new LinkedHashSet<TreeMap>(); //legal because TreeMap is superType of itself

setOfAllSuperTypeOfTreeMap = new HashSet<SortedMap>(); //legal because SorteMap is super degree of TreeMap
setOfAllSuperTypeOfTreeMap = new LinkedHashSet<Map>(); //legal since Map is super type of TreeMap

7) You tin non usage Generics inwards the .class token, parametrized types similar List<String> are non allow along amongst .class literal.

List.class //legal
List<String>.class  //illegal

This is the 1 house where you lot bespeak to usage Raw type instead of parameterized type inwards Java.

8) If you lot are writing Generics method hence you lot bespeak to declare type parameters inwards method signature betwixt method modifiers together with render type every bit shown inwards below Java Generics illustration :

 public static <T> T identical(T source){
        return source;
 }

failing to declare <T> volition resultant inwards compile fourth dimension error. to know to a greater extent than read How to write Generics method inwards Java

Generics notations together with naming Convention

One of the reasons Generics looks tough is due to non-familiarity of diverse Generics price together with naming conventions. Once you lot know pregnant together with advert of diverse price inwards generics you lot volition experience to a greater extent than comfortable amongst Generics inwards Java. Following are some of the oftentimes used price inwards Generics:

Generic Term	Meaning
Set<E>	Generic Type , E is called formal parameter
Set<Integer>	Parametrized type , Integer is actual parameter here
<T extends Comparable>	Bounded type parameter
<T super Comparable>	Bounded type parameter
Set<?>	Unbounded wildcard
<? extends T>	Bounded wildcard type
<? Super T>	Bounded wildcards
Set	Raw type
<T extends Comparable<T>>	Recursive type bound

T – used to announce type

E – used to announce element

K – keys

V - values

due north – for numbers

Array together with Generics inwards Java

1) Arrays don't back upward Generics inwards Java hence you lot tin non create Arrays similar T[] which makes gentrifying an existing degree difficult if you lot are using arrays. Though at that spot is a workaround which requires a cast from Object[] to T[] which comes amongst the run a peril of unchecked cast together with warning. For this reason, it's ameliorate to usage Collections classes similar ArrayList together with HashMap over an array.

By the way, those classes are also implemented on top of the array inwards Java but JDK handles at that spot type-safety yesteryear effectively using generics. hither is an illustration of casting Object array to generic array inwards Java :

/**
 * Generics together with Array doesn't gel rattling well, Java doesn’t allow Generics array similar E[]
 * @author Javin Paul
 */
public class GenericVsArray {
 
    public static void main(String args[]){
      Holder<Integer> numbers = new Holder<Integer>(10);
      numbers.add(101);
      System.out.println("Get: " + numbers.get(0));
    }

 
}

/**
 * Generic Holder for asset contents of different object type
 * Generic inwards Java eliminates casting required piece calling get(index) from customer code
 * @param <T>
 */
class Holder<T>{
    private T[] contents;
    private int index = 0;
    public Holder(int size){
        //contents = novel T[size]; //compiler error - generic array creation
        contents = (T[]) new Object[size]; //workaround - casting Object[] to generic Type
    }
 
    public void add(T content){
        contents[index] = content;
    }
 
    public T get(int index){
        return contents[index];
    }
}

Casting code may generate alarm almost "unsafe cast" which tin live suppressed yesteryear using annotation @SuppressWarnings("unchecked") amongst a proper comment that why it volition non compromise type-safety. This is also 1 of the Java Generics best practices suggested inwards all fourth dimension classic majority Effective Java yesteryear Joshua Bloch.

Generics inwards Java – Benefits together with advantages

Generics adds lot of value to Java programming language, hither are some of the of import benefits of using Generics inwards Java:

Type-safety

Most of import payoff of Generics inwards Java is type-safety. Collections prior to JDK1.5 are non type-safe because they convey Object type declaration which allows them to grab all type of objects instead of alone required the type of object. For example, if you lot desire to create an ArrayList of Stocks together with you lot don't desire that ArrayList also incorporate whatever other asset degree you lot tin usage generics characteristic of coffee to create a type-safe collection. Here is an illustration of using Generics to create a type-safe ArrayList

ArrayList<Stocks> stockList = new ArrayList<Stocks>();

stockList.add(“coins”); //compiler error , String non allowed

The compiler volition guarantee that alone Stock object volition live inserted inwards stockList together with volition throw a compiler error if you lot essay to insert different type of Object.

No Casting

With Generics you lot don’t bespeak to cast object , Generics volition automatically do that for you. For illustration hither is the code for adding together with retrieving an chemical component inwards List amongst together with without Generics inwards Java:

List  items = new ArrayList();
items.add("chocolates");
String item = (String) items.get(0)

List<String> items = new ArrayList();
items.add("biscuits");
String item = items.get(0) //no cast required

Since no cast required, the resultant is clear together with robust code.

No ClassCastException

With Generics compiler ensures that right types are added into Java collection classes together with no cast is required piece retrieving an element, So at that spot is no run a peril of ClassCastException at runtime.

Generics inwards Java – Important points

Some of import characteristic of Generics inwards Java worth remembering:

1) One limitation of Generics inwards Java is that it tin non live applied to primitive type, for example, you lot tin non create exceed primitives inwards angle bracket that volition resultant inwards compilation error, for Example, ArrayList<int> volition resultant inwards compilation error, This is piffling counter-intuitive that why auto-boxing tin non convert int to Integer. If you lot essay the same matter amongst our Generic Holder degree you lot volition acquire next compilation error:

Holder<int> numbers = new Holder<int>(10); //compiler error - unexpected type required: reference found:int

2) Generics inwards Java eliminates ClassCastException piece retrieving objects from Collection, Remember prior to JDK1.5 if you lot retrieve objects from Collection you lot root banking concern check for a particular type together with hence cast, no bespeak to do it now.

ArrayList<Stocks> stockList = new ArrayList<StockList>();
Stock sony = new Stock("Sony","6758.T");
stockList.add(sony);
Stock retreivedStock = stockList.get(sony); //no cast requires – automatic casting yesteryear compiler

3) H5N1 parametrized degree inwards Java usage formal type parameters to retrieve Type information when an event of parametrized degree gets created. In below illustration of generics degree inwards Java <K,V> are formal parameters.

interface Cache <K,V>{
        public V get();
        public V put(K key, V value);
}

As per convention followed on Generics version of Java Collection bundle nosotros tin usage <K,V> for key together with value type parameters.

4) Generics are often related to Templates inwards C++, though Unlike "Template" inwards C++, which creates a novel type for each specific parametrized type, parametrized degree inwards Java is alone compiled 1 time and, to a greater extent than importantly, at that spot is simply 1 unmarried degree file which is used to create instances for all the specific types.

5) Generics inwards Java tin non alone apply to Java Classes but also on methods, hence you lot tin write your ain generics methods inwards Java every bit shown inwards Rules of Generics inwards Java section, hither is some other illustration of parametrized method from Java collection package.

boolean add(E o){}

Here E volition live replaced yesteryear actual type parameter when this method volition acquire called.

6) Another worth noting characteristic of Generics inwards Java is its mightiness to bound Types parameters, for illustration inwards the parametric annunciation of Holder<T extends Closeable>, type parameter listing <T extends Closeable> requires that actual parameter T must live either Closeable or sub-type of Closeable. This is called bounded type parameters inwards Generics . this variety of annunciation allows you lot to telephone phone a method of the Closeable interface without casting type parameter into Closeable. read to a greater extent than almost these type parameters inwards bounded together with unbounded wildcards inwards Generics.

7) Type inference : Generics inwards Java does non back upward type inference piece calling constructor or creating event of Generic Types until JDK7, In Java vii along amongst Automatic resources management together with String inwards Switch  also added a novel operator called Diamond operator together with denoted yesteryear <> which facilitate type inference piece creating event of Generics classes. this helps to trim down redundancy together with clutter. hither is an illustration of Diamond operator inwards Java7 code:

//prior to JDK 7
HashMap<String, Set<Integer>> contacts = new HashMap<String, Set<Integer>>()

//JDK vii diamond operator
HashMap<String, Set<Integer>> contacts = new HashMap<>()

code amongst the diamond operator is much cleaner than the previous one.

On related banking concern annotation Generics inwards Java supports type inference piece calling Generic methods together with this characteristic tin live used to create inwards a combination of Factory pattern pattern inwards Java to create static mill method corresponding to each constructor. for example

//type inference inwards generic method
public static <K,V> HashMap<K,V> newContacts() {
   return new HashMap<K,V>();
}

hence nosotros tin supervene upon telephone phone to constructor amongst this static mill method every bit shown below :

HashMap<String, Set<Integer>> contacts = newContacts();

this tin live used every bit an option to the diamond operator inwards Java v or 6.

Section for absolute beginners on Generics inwards Java

If you lot are absolute beginners inwards generics those angle bracket "<>" may human face foreign together with unreadable to you. Though is non a consummate tutorial on Java Generics together with I would advise you lot to read Java docs on Generics I volition essay to give at to the lowest degree some basic thought of generics inwards Java to acquire you lot going. Remember Generics inwards coffee are introduced to enforce type-safety particularly on collection classes of coffee which holds the type of Object e.g. ArrayList, HashMap.

Type-safety way the compiler volition verify the type of degree during compile fourth dimension together with throw a compiler error if it flora the improper type. For example,if an ArrayList of Gold contains Silver compiler volition throw an error.

ArrayList<Gold> goldList = novel ArrayList<Gold>();

<Gold> tells compiler that this ArrayList must incorporate alone Gold.

Generics tin also live used to write parametric classes similar Cache<Key, Value> on which type of Key together with Value tin live specified piece creating objects.

Parameters used to write code is called "formal type parameters" together with parameters which passed piece creating an event of a generic degree inwards coffee is called "actual type parameters". For illustration inwards our generic cache (below) <K, V> are formal parameter piece novel LRUCache<String, Integer>() volition live actual parameters.

Generics wild cards Example inwards Java

There are to a greater extent than often than non 2 kinds of wildcards inwards Generics, Bounded together with unbounded. Bounded wildcards tin live written inwards 2 ways to announce upper outflow together with lower bound. <?> is called unbounded wildcards because it tin convey whatever Type piece <? extends T> together with <? super T> are bounded wildcards. To know to a greater extent than almost them run into my post:  Bounded vs Unbounded wildcards inwards Generics .

Now let’s run into illustration of different wildcards inwards Generics:

<?>

"?" denotes whatever unknown type, It tin stand upward for whatever Type at inwards code for. Use this wildcard if you lot are non certain almost Type. for example, if you lot desire to direct maintain an ArrayList which tin run amongst whatever type than declare it as  "ArrayList<?> unknownList" together with it tin live assigned to whatever type of ArrayList every bit shown inwards next an illustration of generics inwards Java:

ArrayList<?> unknownList = new ArrayList<Number>();
unknownList = new ArrayList<Float>();

<? extends T>

This is piffling restrictive than the previous 1 it volition allow All Types which are either "T" or extends T way a subclass of T. for example List<? extends Number> can hold List<Number> or List<Integer>

ArrayList<? extends Number> numberList = new ArrayList<Number>();
numberList = new ArrayList<Integer>();
numberList = new ArrayList<Float>();

<T super ?>

This is simply contrary of previous one, It volition allow T together with super classes of T, e.g. List<? super Integer> can concur List<Integer> or List<Number>.

ArrayList<? super Integer> numberList = new ArrayList<Number>();
numberList = new ArrayList<Integer>();
numberList = new ArrayList<Float>(); //compilation error

Generics Best Practices inwards Java

After learning almost how to usage Generics inwards Java for writing type-safe classes, methods together with collection, it's worth noting to recall best practices related to Generics coding:

1) Avoid using Raw types for novel code. Always usage Generics together with write parametrized classes together with method to acquire the total do goodness of compiler checking.

2) Prefer Collection classes over Array inwards your parametrized degree because Generics together with Arrays are completely different to each other, Array concur type information at runtime, dissimilar Generics whose type information is erased yesteryear type-erasure during run time.

3) Use Bounded type parameter to growth flexibility of method arguments together with API

4) Use @SuppressedWarning("unchecked") at every bit narrow compass every bit possible similar instead of annotating a method, simply annotate a line. Also, document rationale of why this cast is type-safe every bit code comments.

5) Convert your raw type classes into a type-safe parametric degree using Generics inwards Java every bit together with when fourth dimension allows, that volition brand the code to a greater extent than robust.

Generic inwards Java is a rattling vast topic together with at that spot are a lot to a greater extent than to larn to acquire expertise on Java Generics. I hope this volition serve you lot a goodness starting betoken inwards price of reading code is written using Generics together with acquire over amongst a complex wild carte du jour of Generics. Java Generics is 1 of the beautiful characteristic together with 1 time you lot used it you lot won’t write classes or methods without generics.

Initially, Generics looks tough together with complex but it's worth learning, given type-safety benefits it provides. Two things I would advise you lot to do every bit beginner root write collection code e'er using Generics together with write some type-safe classes which tin convey parameter e.g. type-safe cache Cache<Key, Value>

Further Learning
Introduction to Collections & Generics inwards Java
Java Fundamentals: Collections
Data Structures together with Algorithms: Deep Dive Using Java

Share this post