Why to Use Generics in JAVA

How many times have you faced a Java.lang.ClassCastException while handling Collections?
Even if you are a good programmer then also you must have faced this problem sometimes or the other, and if you are not then of course many a times :-). Actually, it’s not about being a good or bad programmer, but it’s just about how attentive you are while writing the code using Collections. And the Java.lang.ClassCastException occurs while downcasting any java object. i.e. you are actually trying to cast an object which is at a comparatively higher level in the parent-child hierarchy into an object which is at lover level of parent-child hierarchy.

You must be thinking, why the hell I am talking about this java Exception explicitly while discussing the Generics feature. The reason is that Generics are the most useful mans of avoiding this ClassCastException exception while working with Collections. In a way Collections are the main application area of Generics. This is because Collections can store anything i.e. Objects. And when you have objects stored in Collections, such as Hashtable, you obviously need to remember what you inserted and what you have to take out. The main problem is that, when you take the object out, then you need to explicitly cast that object into an appropriate type, depending on what you inserted initially before you can perform any operation specific to the type of the Object.

Let’s look at the following code snippet:

1 public void createCollection () {
2 ArrayList testlist = new ArrayList();
3 testlist.add(new String("sanjeev"));
4 testlist.add(new Integer(9)); // to cause runtime ClassCastException
5 iterateThroughCollection(testlist);
6 }
7
8
9 protected void iterateThroughCollection(Collection collection) {
10 Iterator i = collection.iterator();
11 while (i.hasNext()) {
12 String element = (String) i.next();
13 }
14 }

Here first we declared a Collection ArrayList (using method createCollection()) testlist and put two items in it. Note that one item is an Integer and the other is a String type. Then we are iterating through the collection and taking out each element of it and typecasting it to String object.

So what happens when you actually execute the createCollection() method? Of course you would get a ClassCastException!! This is because; as I mentioned the Collection classes store each element as Object. This is advantageous in terms of providing us the flexibility and abstraction, but looking a little deeper you realize that it requires you doing an extra work of figuring out what Objects were inserted in collection before they can be used in your code after taking them out of the collection.

Let’s see why??

Going back to the code snippet again now, there are two Objects in the testlist collection, an Integer and a String. But as they are "stored" as Objects, we require typecasting them explicitly to the original data types (see line 12 of the code snippet above). And this is something which the developer should take care of as downcasting (Object to whatever type you inserted originally, String or Integer in this case) is not checked by the compiler. In this way there is always chance that the developers forget and a ClassCastException is thrown, as it happens in the above example. The above code will compile successfully but will fail at the runtime throwing ClassCastException at the line 12; while trying to cast the Integer Object to String Object!!

Now, if you can relate any of your past nightmares to this problem and feel that it would be worthy to remove this problem altogether without taking much of an effort and without increasing the complexity of the code, go ahead and read the rest of the post, otherwise just chuck it here itself and wait for the next nightmare to come back to this line again. As I feel eventually you will have to come!!!

Formers please move ahead in every aspect (reading as well as smart coding practice :-))

Using Generics you can avoid such problems while using Collections in JAVA. Before getting into deep explanation, let’s have a proper definition. Here it goes:

Note: If you are a C++ programmer, you can relate Generics to the C++ templates, as it is similar to the C++ templates in syntax and semantics both and comparatively a little simpler. But there is a difference. The difference lies in the fact that templates generate a new class for each specialization while Generics don't. Also Generics, unlike C++ templates, do not permit “template metaprogramming.”

Generics in Java 1.5: Generics in Java is a means of creating parameterized objects, i.e. specifying the objects that a class can work with at the time of declaring the objects. This is done by passing parameters in angular braces <>. These objects are then evaluated at the compile time itself unlike at the run time as is the case without Generics.

OK....I don't think those lines gave you very clear idea.

Let’s look at it with another example:

ArrayList<string> testlist = new ArrayList<string>();

Look at the above declaration. Did you notice the <Type>(); attached with the classname ArrayList? Of course you did!! So there you are. This is the whole concept of declaring the generic objects. The code is read as “of Type”, so the above ArrayList declaration will be read as “ArrayList of String testlist.” Looking at the code, you would never deny that it is quite clear and readable. Moreover, I feel that it gives you a very clear idea of what the collection is going to contain and therefore what kind of operations you can carry out on the items that you will retrieve from this collection. The above ArrayList, testlist, now can contains only String Objects and therefore the complier knows that the elements are going to be String types and therefore you need not actually typecast the retrieved objects to String.

Thus, we achieved the following out of it:

1. Eliminated an unsafe cast and a number of extra parentheses form your code.
2. Inserted valuable information (that the testlist will only contain the String objects) about the object in the declaration itself.
3. Provided ability to the compiler to verify at the compile time that the type constraints are not violated at run time.
4. Improved readability and robustness.

And most importantly the above three factors increase your self confidence and you can say your boss (If you still face a ClassCastException) with certainty that your code is innocent :-).

So before closing, let's see the above example with Generics:

1 public void createCollection() {
2 ArrayList<string> testlist = new ArrayList<string>();
3 testlist.add(new String("sanjeev"));
4 // testlist.add(new Integer(9)); this line wont compile as the ArrayList is already declared of String Type and here you are trying to put in Integer.
5 iterateThroughCollection(testlist);
6 }
7
8
9 protected void iterateThroughCollection(Collection<string> collection) {
10 Iterator<string> i = collection.iterator();
11 while (i.hasNext()) {
12 String element = i.next();
13 }
14 }

At the end, I would like to say the following hoping that you will also agree to this:

"Use generics everywhere you can as one time effort in gentrifying your code is well worth the gains in clarity and type safety."

In the next post related to Generics, I would like to tell you some rules in generics which if you keep in mind, will help you to use generics efficiently. Till then, Happy Reading and Happy Programming. :-)