We will be discussing differences later prior let us understand what is generic Collection and non-generic Collection, and most importantly dealing with the implementation part as during implementation one can only really get the real understanding of the concept, henceforth the differences between them.
Generics are basically the errors appearing are compile-time than at run-time. there are certain advantages of generics over non-generic are as follows:
- Code Reuse: With help of Generics, one needs to write a method/class/interface only once and use it for any type whereas, in non-generics, the code needs to be written again and again whenever needed.
- Type Safety: Generics make errors to appear compile time than at run time (It’s always better to know problems in your code at compile time rather than making your code fail at run time).
Example: To create an ArrayList that store name of students and if by mistake programmer adds an integer object instead of string, the compiler allows it. But, when this data is retrieved from ArrayList, it causes problems at runtime for Non-generic ArrayList
Implementation:
Example 1
Java
// Java program to Demonstrate that Not Using Generics// Can cause Run Time Exceptions// Importing all utility classesimport java.util.*;// Main classclass GFG { // Main driver method public static void main(String[] args) { // Creating an ArrayList // Declaring object without any type specified ArrayList al = new ArrayList(); // Adding elements to the above object // Custom input elements al.add("Sachin"); al.add("Rahul"); // Compiler will allows this operation al.add(10); String s1 = (String)al.get(0); String s2 = (String)al.get(1); // Try block to check for exceptions try { // Causes Runtime Exception String s3 = (String)al.get(2); } // Catch block to handle the exceptions catch (Exception e) { // Display the exception System.out.println("Exception: " + e); } }} |
Output:
prog.java:19: warning: [unchecked] unchecked call to add(E) as a member of the raw type ArrayList
al.add("Sachin");
^
where E is a type-variable:
E extends Object declared in class ArrayList
prog.java:20: warning: [unchecked] unchecked call to add(E) as a member of the raw type ArrayList
al.add("Rahul");
^
where E is a type-variable:
E extends Object declared in class ArrayList
prog.java:23: warning: [unchecked] unchecked call to add(E) as a member of the raw type ArrayList
al.add(10);
^
where E is a type-variable:
E extends Object declared in class ArrayList
3 warnings
How generics solve this problem?
If this list was made Generic, then it would take only String objects and threw Compile Time Error in any other case.
Example 2
Java
// Java Program to Illustrate Conversion of// Runtime Exceptions into compile time errors// Using generics// Importing all utility classesimport java.util.*;// Main classclass GFG { // Main driver method public static void main(String[] args) { // Creating an ArrayList // Declaring object of string type ArrayList<String> al = new ArrayList<String>(); // Adding elements to the ArrayList // Custom input elements al.add("Sachin"); al.add("Rahul"); // Now compiler does not allow this operation al.add(10); String s1 = al.get(0); String s2 = al.get(1); String s3 = al.get(2); }} |
Output:
prog.java:24: error: incompatible types: int cannot be converted to String
al.add(10);
^
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error
Now moving forward, Individual Type Casting is not needed.
If Generics is not needed, then, in the above example every time the data is to be retrieved from ArrayList, it needs to be typecasted. Typecasting at every retrieval operation is a big headache. This can be avoided if somehow it is already known that the list only holds string data.
Example 3
Java
// Java program to Illustrate Type Casting is Needed// Everytime in Non-Generic// Importing all utility classesimport java.util.*;// Main classclass GFG { // Main driver method public static void main(String[] args) { // Creating an ArrayList // Declaring object without any type specified ArrayList al = new ArrayList(); // Adding elements to the above object // using add() method al.add("Sachin"); al.add("Rahul"); // For every retrieval, // it needs to be casted to String for use String s1 = (String)al.get(0); String s2 = (String)al.get(1); }} |
Output:
Geek, now you should be wondering how generics solve this problem?
If this list was made Generic, then it would take only String objects and would return only String objects while retrieval. And hence individual typecasting won’t be required. The above statement is justified
Example 4
Java
// A Simple Java program to demonstrate that// type casting is not needed in Genericimport java.util.*;class Test { public static void main(String[] args) { // Creating an ArrayList // Declaring object of type String ArrayList<String> al = new ArrayList<String>(); // Custom input elements al.add("Sachin"); al.add("Rahul"); // Retrieval can be easily // without the trouble of casting String s1 = al.get(0); String s2 = al.get(1); // Print and display out the elements in objects System.out.print(al); }} |
[Sachin, Rahul]
Note:
With the help of generics, while one can implement algorithms Implementing generic algorithms, one can have that work on different types of objects and at the same they are type-safe too.
Do remember that there are some points, which will describe the difference between Generics and Non-Generic which are tabulated below in order to get a crisp understanding between them.
| Base | Non-generic Collection | Generic Collection |
|---|---|---|
| Syntax | ArrayList list = new ArrayList(); | ArrayList<ReferenceType> list = new ArrayList<ReferenceType>(); |
| Type-safety | Can hold any type of data. Hence not type-safe. | Can hold only the defined type of data. Hence type safe. |
| Typecasting | Individual type casting needs to be done at every retrieval. | No typecasting is needed. |
| Compile-Time Checking | Checked for type safety at runtime. | Checked for type safety at Compile-time. |
