Collection Framework in Java – Hierarchy, Need & Advantages

In the day-to-day life of a programmer, we are required to maintain a given set of data. Java has different collections like list, Stack, Queue, etc to maintain this set of data. To make the work of a programmer even simpler, java also has a collection framework, which implicitly uses collections to maintain a set of data. In this article, we will take a look at exactly what java collection framework is and what are the main advantages of using the collection framework.

Collection in Java:

A collection is a group of individual data, that are grouped together to form a single unit. Collections are containers that hold multiple data as a single unit. For example, if we store the names of all the employees in a single list and name it as Employee, it will form a collection.
The two root interfaces of java collection class are:

• Collection interface(java.util.collection)
• Map interface(java.util.Map)

Collection Framework in Java:

Collection Framework in Java is an architecture using which we can represent a collection of interfaces and classes. It is used in storing, maintaining and handling data effectively.
The collection framework makes manipulation of the collection easier. This makes the task of a programmer simpler.

Hierarchy of Collection Framework in Java:

As we know, the collection framework is an architecture of classes and interfaces. Let us now see their hierarchy.

Need for Java Collection Framework:

Java collection framework was introduced from Java 1.2 version, before that java had some ad hoc classes like vector, properties, stack, hash tables, dictionary, etc to store and handle data. These classes were useful but did not have the same interface,i.e, the technique of storing data was different for different classes. That is why the collection framework was introduced in java 1.2 to make these classes unified.

Goals of Collection Framework in Java:

• To Increase the efficiency of the fundamental collections like dynamic arrays, trees, linked lists and hash tables, etc.
• To increase compatibility by letting all the collections work in an identical manner.
• For increasing flexibility by easily extending and/or adapting a collection.
• To increase the efficiency of the code due to the high optimization of the collection framework.
• To increase the uniqueness of data by providing the set interface.
• For making the organization of data easier by storing the data in key and value pair using the Map interface.
• To increase flexibility of arrays by using the ArrayList class.

Composition of Java Collection Frameworks:

All collection frameworks in java include the following three elements:
1. Interfaces
2. Implementation or classes
3. Collection Algorithms

Let us discuss them individually.

1. Interfaces in java:

The main architecture of the java collection framework stands on the basis of interfaces. Interfaces are abstract data types that represent collections in the framework. Using interfaces we can manipulate collections irrespective of the way they are represented in the memory. All these interfaces are part of the utility package of java, i.e, java.util.

The root of the Collection framework interfaces is java.util.Collections. It consists of several important methods that the programmer uses in his day to day life. Some of these methods include add(), size(), remove(), etc.
Each and every other interface implements the java.util.Collection interface, for example, Set, Queue, etc. The only interface that does not implement the collection interface but is part of the framework is the Map interface.

The table below tells us about the different interfaces and their work in the Collection framework.

2. Implementation:

Java collection framework architecture’s next component is the implemented classes. These classes are the concrete implementation of the collection interface, i.e, these classes are reusable data structures. We can use them repeatedly to create different collections in our code. Some of the most important classes are ArrayList, LinkedList, HashMap, TreeMap, HashSet, TreeSet, etc. We can even create our own customized collection classes.

Let us understand the main classes of the collection framework by the following table:

3. Java Collection Algorithms:

The collection framework has several predefined algorithms that can be applied to the Collection and Map interface. These algorithms are defined as static methods and are present inside the Collection interface. These algorithms are polymorphic, i.e, they can be implemented as many times as required.

Many of these methods can throw a ClassCastException, which occurs when an attempt is made to compare incompatible types, or an UnsupportedOperationException, which occurs when an attempt is made to modify an unmodifiable collection.

The following table explains all the collection framework algorithms:

Code to explain the use of algorithms:

package com.DataFlair.CollectionFramework;
import java.util.*;
public class Algorithms
{
    public static void main(String args[]) {
      LinkedList L1 = new LinkedList();
      L1.add(new Integer(15));
      L1.add(new Integer(2));
      L1.add(new Integer(-2));
      L1.add(new Integer(1000));
      Comparator r = Collections.reverseOrder();
      Collections.sort(L1, r);
      Iterator li = L1.iterator();
      System.out.print("List sorted in reverse: ");
      while(li.hasNext()) {
         System.out.print(li.next() + " ");
      }
      System.out.println();
      Collections.shuffle(L1);
      li = L1.iterator();
      System.out.print("List shuffled: ");
      while(li.hasNext()) {
         System.out.print(li.next() + " ");
      }
      System.out.println();
      System.out.println("Minimum: " + Collections.min(L1));
      System.out.println("Maximum: " + Collections.max(L1));
   }
}

The output of the above code:

As we can see how the use of algorithms can make programs short and simple.

Java Iterator Interface in Collection Framework:

There is no point in storing data using collections if we can’t cycle through them. Java provides us with a very simple interface to do this, known as Iterator or ListItertor, depending upon what type of collection needs to be iterated. Iterator enables you to cycle through a collection to obtain or remove elements.

ListIterator extends the Iterator interface to allow bidirectional traversal of a list and the modification of elements. These are very useful especially in the case of various operations that require constant cycling through the list.

Code to understand Iterator implementation:

package com.DataFlair.CollectionFramework;
import java.util.*;
public class Iterators
{
     public static void main(String args[]) 
     {
      ArrayList al = new ArrayList();
      al.add("D");
      al.add("A");
      al.add("T");
      al.add("A");
      al.add("F");
      al.add("L");
      al.add("A");
      al.add("I");
      al.add("R");
      System.out.print("Original contents of al: ");
      Iterator itr = al.iterator();
      while(itr.hasNext()) {
         Object element = itr.next();
         System.out.print(element + " ");
      }
      ListIterator litr = al.listIterator();
      while(litr.hasNext()) {
         Object element = litr.next();
         litr.set(element + "+");
      }
      System.out.print("\nModified contents of al: ");
      itr = al.iterator();
      while(itr.hasNext()) {
         Object element = itr.next();
         System.out.print(element + " ");
      }
      System.out.print("\nModified list backwards: ");  
      while(litr.hasPrevious()) {
         Object element = litr.previous();
         System.out.print(element + " ");
      }
   }
}

The output of the above code:

Java Comparator Interface in Collection Framework:

The comparator interface gives us the provision to compare two instances of a class or two elements in a collection of data. The Comparator interface consists of two methods: the compare method and the equals method.

The compare method:

int compare(Object obj1, Object obj2)

The compare method returns:

• negative if obj1 < obj2
• zero if obj1 == obj2
• positive if obj1 > obj2

The equal method:

boolean equals(Object obj)

The equal() method returns true if the equality satisfies the object.

Code to understand comparator implementation:

package com.DataFlair.CollectionFramework;
import java.util.*;
class Dog implements Comparator<Dog>, Comparable<Dog> 
  {
   private String name;
   private int age;
   Dog() {
   }
   Dog(String n, int a) {
      name = n;
      age = a;
   }
   public String getName() {
      return name;
   }
   public int getAge() {
      return age;
   }
   public int compareTo(Dog d) {
      return (this.name).compareTo(d.name);
   }
   public int compare(Dog d, Dog d1) {
      return d.age - d1.age;
   }
}
public class Example {
   public static void main(String args[]) 
   {
     List<Dog> list = new ArrayList<Dog>();
     list.add(new Dog("Scooby", 3));
     list.add(new Dog("Bruno", 2));
     list.add(new Dog("Oreo", 10));
     list.add(new Dog("Darcy", 4));
     list.add(new Dog("Tommy", 1));
     Collections.sort(list);
     for(Dog a: list)
         System.out.print(a.getName() + ", ");
     Collections.sort(list, new Dog());
     System.out.println(" ");
     for(Dog a: list) 
         System.out.print(a.getName() +"  : "+ a.getAge() + ", ");
   }
}

The output of the above code:

Advantages of Java Collection Framework:

Java Collection framework has several advantages, few of them include:
1. Consistent API: Java collection framework consists of a consistent API that has all the essential arrangement of interfaces like collections, Lists, Set, List, etc, and classes that implement the interfaces like ArrayList, Vector, etc.

2. Reduce Programming Exertion: The collection framework provides various provisions to implement an operation at an ease, this helps the programmer to focus on the main task, rather than the basic operations.

3. Increases Program Quality and Speed: The collection Framework helps to increase the execution speed and quality by reducing program size and letting the programmer handle data at an ease.

Conclusion:

No doubt that the Java Collection Framework makes the programmer’s task simpler. Not just that, by reducing the hassles of writing the operations manually, the java framework enables programmers to solve bigger problems at an ease. This is the reason why the Java collection framework is so important. In this article, we saw the basic structure of the Java collection framework, as well as how to implement a few of the important methods.