Differentiation of Collections Framework in Java

If you interested to learn about the Java Data Structures

The Collection in Java is a framework that provides an architecture to store and manipulate the group of objects. Java Collections can achieve all the operations that you perform on a data such as searching, sorting, insertion, manipulation, and deletion. Java Collection means a single unit of objects. Java Collection framework provides many interfaces (Set, List, Queue, Deque) and classes (Array List, Vector, Linked List, Priority Queue, Hash Set, Linked Hash Set, Tree Set).

Java provided ad hoc classes such as Dictionary, Vector, Stack, and Properties to store and manipulate groups of objects. Although these classes were quite useful, they lacked a central, unifying theme. Thus, the way that you used Vector was different from the way that you used Properties.

The collections framework was designed to meet several goals, such as −

  • The framework had to be high-performance. The implementations for the fundamental collections (dynamic arrays, linked lists, trees, and hashtables) were to be highly efficient.
  • The framework had to allow different types of collections to work in a similar manner and with a high degree of interoperability.
  • The framework had to extend and/or adapt a collection easily.

Towards this end, the entire collections framework is designed around a set of standard interfaces. Several standard implementations such as LinkedList, HashSet, and TreeSet, of these interfaces are provided that you may use as-is and you may also implement your own collection, if you choose. A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following −

  • Interfaces − These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.
  • Implementations, i.e., Classes − These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.
  • Algorithms − These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface.

In addition to collections, the framework defines several map interfaces and classes. Maps store key/value pairs. Although maps are not collections in the proper use of the term, but they are fully integrated with collections.

The Collection Interfaces

The collections framework defines several interfaces. This section provides an overview of each interface −

Sr.No.Interface & Description
1The Collection Interface – This enables you to work with groups of objects; it is at the top of the collections hierarchy.
2The List Interface -This extends Collection and an instance of List stores an ordered collection of elements.
3The Set -This extends Collection to handle sets, which must contain unique elements.
4The SortedSet – this extends Set to handle sorted sets.
5The Map -This maps unique keys to values.
6The Map.Entry -This describes an element (a key/value pair) in a map. This is an inner class of Map.
7The SortedMap – This extends Map so that the keys are maintained in an ascending order.
8The Enumeration -This is legacy interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects. This legacy interface has been superceded by Iterator.

The Collection Classes

Java provides a set of standard collection classes that implement Collection interfaces. Some of the classes provide full implementations that can be used as-is and others are abstract class, providing skeletal implementations that are used as starting points for creating concrete collections.

The standard collection classes are summarized in the following table −

Sr.No.Class & Description
1Abstract Collection -Implements most of the Collection interface.
2Abstract List – Extends AbstractCollection and implements most of the List interface.
3Abstract Sequential List -Extends AbstractList for use by a collection that uses sequential rather than random access of its elements.
4Linked List Implements – a linked list by extending AbstractSequentialList.
5Array List – Implements a dynamic array by extending AbstractList.
6Abstract Set Extends – AbstractCollection and implements most of the Set interface.
7Hash Set Extends – AbstractSet for use with a hash table.
8Linked Hash Set Extends – HashSet to allow insertion-order iterations.
9TreeSet Implements a set stored in a tree. Extends AbstractSet.
10AbstractMapImplements most of the Map interface.
11HashMap Extends – AbstractMap to use a hash table.
12Tree Map Extends- AbstractMap to use a tree.
13Weak Hash Map Extends – AbstractMap to use a hash table with weak keys.
14Linked Hash Map Extends – HashMap to allow insertion-order iterations.
15Identity Hash Map Extends – AbstractMap and uses reference equality when comparing documents.

The AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList and AbstractMap classes provide skeletal implementations of the core collection interfaces, to minimize the effort required to implement them.

The following legacy classes defined by java.util have been discussed in the previous chapter −

Sr.No.Class & Description
1Vector -This implements a dynamic array. It is similar to ArrayList, but with some differences.
2Stack -Stack is a subclass of Vector that implements a standard last-in, first-out stack.
3Dictionary -Dictionary is an abstract class that represents a key/value storage repository and operates much like Map.
4Hashtable -Hashtable was part of the original java.util and is a concrete implementation of a Dictionary.
5Properties -Properties is a subclass of Hashtable. It is used to maintain lists of values in which the key is a String and the value is also a String.
6BitSet -A BitSet class creates a special type of array that holds bit values. This array can increase in size as needed.

The Collection Algorithms

The collections framework defines several algorithms that can be applied to collections and maps. These algorithms are defined as static methods within the Collections class. Several of the methods can throw a Class Cast Exception, which occurs when an attempt is made to compare incompatible types, or an Unsupported Operation Exception, which occurs when an attempt is made to modify an unmodifiable collection.

Collections define three static variables: EMPTY_SET, EMPTY_LIST, and EMPTY_MAP. All are immutable.

Sr.No.Algorithm & Description
1The Collection Algorithms – Here is a list of all the algorithm implementation.

How to Use an Iterator ?

Often, you will want to cycle through the elements in a collection. For example, you might want to display each element. The easiest way to do this is to employ an iterator, which is an object that implements either the Iterator or the ListIterator interface.

Iterator enables you to cycle through a collection, obtaining or removing elements. ListIterator extends Iterator to allow bidirectional traversal of a list and the modification of elements.

Sr.No.Iterator Method & Description
1Using Java Iterator – Here is a list of all the methods with examples provided by Iterator and ListIterator interfaces.

How to Use a Comparator ?

Both TreeSet and TreeMap store elements in a sorted order. However, it is the comparator that defines precisely what sorted order means.

This interface lets us sort a given collection any number of different ways. Also this interface can be used to sort any instances of any class (even classes we cannot modify).

Sr.No.Iterator Method & Description
1Using Java Comparator -Here is a list of all the methods with examples provided by Comparator Interface.

Hierarchy of Collection Framework

Let us see the hierarchy of Collection framework. The java.util package contains all the classes and interfaces for the Collection framework.

Hierarchy of Java Collection framework

Methods of Collection interface

There are many methods declared in the Collection interface. They are as follows:

1public boolean add(E e)It is used to insert an element in this collection.
2public boolean addAll(Collection<? extends E> c)It is used to insert the specified collection elements in the invoking collection.
3public boolean remove(Object element)It is used to delete an element from the collection.
4public boolean removeAll(Collection<?> c)It is used to delete all the elements of the specified collection from the invoking collection.
5default boolean removeIf(Predicate<? super E> filter)It is used to delete all the elements of the collection that satisfy the specified predicate.
6public boolean retainAll(Collection<?> c)It is used to delete all the elements of invoking collection except the specified collection.
7public int size()It returns the total number of elements in the collection.
8public void clear()It removes the total number of elements from the collection.
9public boolean contains(Object element)It is used to search an element.
10public boolean containsAll(Collection<?> c)It is used to search the specified collection in the collection.
11public Iterator iterator()It returns an iterator.
12public Object[] toArray()It converts collection into array.
13public <T> T[] toArray(T[] a)It converts collection into array. Here, the runtime type of the returned array is that of the specified array.
14public boolean isEmpty()It checks if collection is empty.
15default Stream<E> parallelStream()It returns a possibly parallel Stream with the collection as its source.
16default Stream<E> stream()It returns a sequential Stream with the collection as its source.
17default Spliterator<E> spliterator()It generates a Spliterator over the specified elements in the collection.
18public boolean equals(Object element)It matches two collections.
19public int hashCode()It returns the hash code number of the collection.


The Java collections framework gives the programmer access to prepackaged data structures as well as to algorithms for manipulating them. A collection is an object that can hold references to other objects. The collection interfaces declare the operations that can be performed on each type of collection.

Differentiation of Collections Framework in Java
Show Buttons
Hide Buttons