What is a Java Collection Framework?

A Java collection framework provides an architecture to store and manipulate a group

of objects. A Java collection framework includes the following:

• Interfaces
• Classes
• Algorithm

Let’s learn about them in detail:

Interfaces: Interface in Java refers to the abstract data types. They allow Java
collections to be manipulated independently from the details of their representation.
Also, they form a hierarchy in object-oriented programming languages.

Classes: Classes in Java are the implementation of the collection interface. It

basically refers to the data structures that are used again and again.

Algorithm: Algorithm refers to the methods which are used to perform operations
such as searching and sorting, on objects that implement collection interfaces.
Algorithms are polymorphic in nature as the same method can be used to take many
forms or you can say perform different implementations of the Java collection
interface.

The Java collection framework provides the developers to access prepackaged data
structures as well as algorithms to manipulate data. Next, let us move to the
Java collections framework hierarchy and see where these interfaces and
classes resides.

Java Collection Framework Hierarchy

As we have learned Java collection framework includes interfaces and classes. Now,
let us see the Java collections framework hierarchy.
Java Collections : Interface
Iterator interface : Iterator is an interface that iterates the elements. It is used to
traverse the list and modify the elements. Iterator interface has three methods which
are mentioned below:

1. public boolean hasNext() – This method returns true if the iterator has more
elements.
2. public object next() – It returns the element and moves the cursor pointer to
the next element.
3. public void remove() – This method removes the last elements returned by
the iterator.

There are three components that extend the collection interface i.e List, Queue and
Sets. Let’s learn about them in detail:
Java collections: List
A List is an ordered Collection of elements which may contain duplicates. It is an
interface that extends the Collection interface. Lists are further classified into the
following:

1. ArrayList
2. LinkedList
3. Vectors

Array list: ArrayList is the implementation of List Interface where the elements can be
dynamically added or removed from the list. Also, the size of the list is increased
dynamically if the elements are added more than the initial size.

Syntax:

ArrayList <datatype> object = new ArrayList <datatype> ();

ArrayList() It is used to build an empty array list.

ArrayList(Collection<? It is used to build an array list that is initialized with
extends E> c) the elements of the collection c.
It is used to build an array list that has the specified
ArrayList(int capacity)
initial capacity.
Some of the methods in array list are listed below:

Method Description
boolean add(Collection
Appends the specified element to the end of a list.
c)

void add(int index,

Inserts the specified element at the specified position.
Object element)
void clear() Removes all the elements from this list.
Return the index in this list of the last occurrence of the
int lastIndexOf(Object
specified element, or -1 if the list does not contain this
o)
element.
Object clone() Return a shallow copy of an ArrayList.

Object[] toArray() Returns an array containing all the elements in the list.

Trims the capacity of this ArrayList instance to be the list’s

void trimToSize()
current size.

Let us understand Array list with a programmatic example:

import java.util.*;

class ArrayListExample{

public static void main(String args[]){

ArrayList <String> al=new ArrayList <String> (); // creating array list

al.add("Jack"); // adding elements

al.add("Tyler");

Iterator itr=al.iterator();

while(itr.hasNext()){

System.out.println(itr.next());

}
}

In the above code, it will return the names that we have added using add() method i.e:

Jack

Tyler

Linked List: Linked List is a sequence of links which contains items. Each link contains
a connection to another link.

Syntax: Linkedlist <datatype> object = new Linkedlist <datatype> ();

Java Linked List class uses two types of Linked list to store the elements:

• Singly Linked List

• Doubly Linked List

Singly Linked List: In a singly Linked list each node in this list stores the data of the
node and a pointer or reference to the next node in the list. Refer to the below image to
get a better understanding of single Linked list.

Doubly Linked List: In a doubly Linked list, it has two references, one to the next
node and another to previous node. You can refer to the below image to get a better
understanding of doubly linked list.

Some of the methods in the linked list are listed below:

Method Description
It is used to append the specified element to the end of
boolean add( Object o)
the vector.
boolean contains(Object
Returns true if this list contains the specified element.
o)
void add (int index,
Inserts the element at the specified element in the vector.
Object element)

void addFirst(Object o) It is used to insert the given element at the beginning.

void addLast(Object o) It is used to append the given element to the end.

int size() It is used to return the number of elements in a list

boolean remove(Object Removes the first occurrence of the specified element
o) from this list.
int indexOf(Object Returns the index of the first occurrence of the specified
element) element in this list, or -1.
int lastIndexOf(Object Returns the index of the last occurrence of the specified
element) element in this list, or -1.

Let us understand linked list with a programmatic example:

import java.util.*;

public class LinkedlistExample{

public static void main(String args[]){

LinkedList<String> al=new LinkedList<String>();// creating linked list

al.add("Rachit"); // adding elements

al.add("Rahul");

al.add("Rajat");

Iterator<String> itr = al.iterator();

while(itr.hasNext()){

System.out.println(itr.next());

}
}

The output of the above program would be:

Rachit

Rahul

Rajat

Vectors : Vectors are similar to arrays, where the elements of the vector object can
be accessed via an index into the vector. Vector implements a dynamic array. Also,
the vector is not limited to a specific size, it can shrink or grow automatically whenever
required. It is similar to ArrayList, but with two differences :

• Vector is synchronized.
• Vector contains many legacy methods that are not part of the collections
framework.

Syntax:

vector <datatype> object = new vector <datatype> ();

 It constructs an empty vector with the default size
1) vector()
as 10.
It constructs an empty vector with the specified
2) vector(int initialCapacity) initial capacity and with its capacity increment
equal to zero.
vector(int initialCapacity, int It constructs an empty vector with the specified
3)
capacityIncrement) initial capacity and capacity increment.
Vector( Collection<? extends E> It constructs a vector that contains the elements of a
4)
c) collection c

Below are some of the methods of the Vector class:

Method Description
Appends the specified element to the end of the
boolean add(Object o)
list.
void clear() Removes all of the elements from this list.
void add(int index, Object Inserts the specified element at the specified
element) position.
Removes the first occurrence of the specified
boolean remove(Object o)
element from this list.
boolean contains(Object Returns true if this list contains the specified
element) element.
int Returns the index of the first occurrence of the
indexOfObject (Object element) specified element in the list, or -1.
int size() Returns the number of elements in this list.
Return the index of the last occurrence of the
int lastIndexOf(Object o) specified element in the list, or -1 if the list does
not contain any element.

Java collections: Queue

Queue in Java follows a FIFO approach i.e. it orders the elements in First In First Out
manner. In a queue, the first element is removed first and last element is removed in
the end. Each basic method exists in two forms: one throws an exception if the
operation fails, the other returns a special value.
Also, priority queue implements Queue interface. The elements of the priority
queue are ordered according to their natural ordering, or by a Comparator provided at
the queue construction time. The head of this queue is the least element with respect
to the specified ordering.

Below are some of the methods of Java Queue interface:

Method Description
boolean Inserts the specified element into the queue and returns true if it
add(object) is a success.

boolean
Inserts the specified element into this queue.
offer(object)

Object remove() Retrieves and removes the head of the queue.

Retrieves and removes the head of the queue, or returns null if

Object poll()
the queue is empty.

Object element() Retrieves, but does not remove the head of the queue.

Retrieves, but does not remove the head of this queue, or returns
Object peek()
null if the queue is empty.

Let us understand these priority queues with a programmatic example:

import java.util.*;

class QueueExample {

public static void main(String args[]){

PriorityQueue<String> queue=new PriorityQueue<String>();

// creating priority queue

queue.add("Amit");

// adding elements

queue.add("Rachit");

queue.add("Rahul");

System.out.println("head:"+queue.element());

System.out.println("head:"+queue.peek());

System.out.println("iterating the queue elements:");

Iterator itr=queue.iterator();

while(itr.hasNext()){

System.out.println(itr.next());

queue.remove();

queue.poll();

System.out.println("after removing two elements:");

Iterator<String> itr2=queue.iterator();

while(itr2.hasNext()){

System.out.println(itr2.next());

}
In the above code, the output would be :

head:Amit

head:Amit

iterating the queue elements:

Amit

Rachit

Rahul

after removing two elements:

Rahul

Java Collections: Sets

A Set refers to a collection that cannot contain duplicate elements. It is mainly used to
model the mathematical set abstraction. Set has its implementation in various classes
such as HashSet, TreeSet and LinkedHashSet.

Let’s go into detail on each one of them:

HashSet: Java HashSet class creates a collection that use a hash table for
storage. HashSet only contain unique elements and it inherits the abstract Set class
and implements Set interface. Also, it uses a mechanism hashing to store the
elements.
Below are some of the methods of Java HashSet class:

Method Description

boolean add(Object o) Adds the specified element to this set if it is not already present.

boolean contains(Object
Returns true if the set contains the specified element.
o)

void clear() Removes all the elements from the set.

boolean isEmpty() Returns true if the set contains no elements.

boolean remove(Object o) Remove the specified element from the set.

Returns a shallow copy of the HashSet instance: the elements

Object clone()
themselves are not cloned.

Iterator iterator() Returns an iterator over the elements in this set.

int size() Return the number of elements in the set.

import java.util.*;

class HashsetExample{

public static void main(String args[]){

HashSet al=new HashSet(); // creating hashSet

al.add("Rachit"); // adding elements

al.add("Amit");

al.add("jack");

Iterator itr=al.iterator();

while(itr.hasNext()){

System.out.println(itr.next());

}
The output of the above code would be:

Amit

Rachit

jack

Linked Hashset : Java LinkedHashSet class is a Hash table and Linked list implementation of the set
interface. It contains only unique elements like HashSet. Linked HashSet also provides all optional set
operations and maintains insertion order.

Let us understand these linked Hashset with a programmatic example:

import java.util.*;

class LinkedHashsetExample{

public static void main(String args[]){

LinkedHashSet al=new LinkedHashSet(); // creating linkedhashset

al.add("Mariana"); // adding elements

al.add("Rick");

al.add("Sam");

Iterator itr=al.iterator();

while(itr.hasNext()){

System.out.println(itr.next());

The output of the above code would be:

Mariana

Rick

Sam

TreeSet : TreeSet class implements the Set interface that uses a tree for storage. The objects of this
class are stored in the ascending order. Also, it inherits AbstractSet class and implements
NavigableSet interface. It contains only unique elements like HashSet. In TreeSet class, access and
retrieval time are faster.
Below are some of the methods of Java TreeSet class:
Method Description

boolean addAll(Collection c) Add all the elements in the specified collection to this set.

boolean contains(Object o) Returns true if the set contains the specified element.

boolean isEmpty() Returns true if this set contains no elements.

boolean remove(Object o) Remove the specified element from the set.

void add(Object o) Add the specified element to the set.

void clear() Removes all the elements from the set.

Object clone() Return a shallow copy of this TreeSet instance.

Object first() Return the first element currently in the sorted set.

Object last() Return the last element currently in the sorted set.

int size() Return the number of elements in the set.

Let us understand these TreeSet with a programmatic example:

import java.util.*;

class TreeSetExample{

public static void main(String args[]){

TreeSet al=new TreeSet (); // creating treeSet

al.add("John"); // adding elements

al.add("Sam");

al.add("Rick");

Iterator itr=al.iterator();

while(itr.hasNext()){

System.out.println(itr.next());

The output of the above program would be:

John

Rick
Sam