Java Collections Framework for Beginners | Realtime examples

Collections framework is one of the most valuable and exciting topics in the Java language.

So why do you think we need Java collections? The Java collection framework provides the developers with access to prepackaged data structures as well as algorithms to manipulate data.

This Java collections framework blog will cover the following topics in depth.

  • What is Collections Framework in Java?

  • Realtime examples of Collection

  • Difference between Array and Collection in Java

  • Advantages Of Java Collections Framework

  • Java collection framework Hierarchy

  • Java Collections: Interfaces

What is Collections Framework in Java?

Java collections can be defined as a group of objects. A collection is usually a single unit consisting of more than one object. You can perform all operations on data such as searching, sorting, insertion, manipulation, deletion, etc. by Java collections.

A framework is software that has a ready-made functional interface or architecture and also contains a set of classes and interfaces to be used with the provided interface.

Let’s understand it with some real-time examples.

Realtime examples of Collection

1. In childhood, you had a kiddy bank. In the kiddy bank, you had collected a lot of coins. This kiddy bank is called collection and the coins are nothing but objects.

2. During school time, you put all the important books in the school bag before going to school. Here Schoolbag is a collection and books are objects.

3. A classroom is a collection of students. So, the classroom is nothing but a collection and students are objects.

4. We know that the entire world is a collection of humans, animals, and different things. The world is a collection and humans, animals and different things are different objects.

Technically, a collection is an object or container which stores a group of other objects as a single unit or single entity. Therefore, it is also known as a container object or collection object in java.

A container object means it contains other objects. In simple words, a collection is a container that stores multiple elements together.

JVM (Java Virtual Machine) stores the reference of other objects into a collection object. It never stores physical copies of other objects because other objects are already available in the memory and storing another copy of objects into a collection object would be a wasting of memory.

A group of objects stored in a collection object is shown in the below figure. In the figure, we are storing 5 objects in a collection object.

A simple example of a collection is given below:

Difference between Arrays & Collections in Java



​ Collections


​Arrays are fixed in size

The Collection is growable in nature.

Memory Consumption

Arrays consume more memory

Collections consume less memory

Data type

An Array can hold only homogeneous type elements

Collection can hold homogeneous and heterogeneous type elements

Data Structure

No underlying data structure is available for arrays

​Every collection class is implemented based on some standard data structure.

Primitives storage

Arrays can hold both object and primitive elements

Collection can hold only object types but primitive elements

Advantages Of Java Collections Framework

  • Reduced programming efforts.

  • Consistent methods and API.

  • Increase speed and accuracy.

  • Facilitates software reuse.

  • Interoperability among unrelated APIs.

  • Fewer efforts to design new APIs.

Java collection framework Hierarchy

The hierarchy of the entire collection framework consists of four core interfaces such as Collection, List, Set, Map, and two specialized interfaces named SortedSet and SortedMap for sorting.

All the interfaces and classes for the collection framework are located in java. util package. The diagram of the Java collection hierarchy is shown in the below figure.

These are the 5 key interfaces of the collection framework which we can use according to our use.

  1. Collection

  2. List

  3. Set

  4. Queue

  5. Map


Although the java Map interface is a Java Collection framework. It doesn’t inherit from the Java Collection framework. Instead, it has its own interface hierarchy that maintains key-value pairs.

Java Collections: Interface

Iterator interface: The 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:




Insertion order is maintained

Insertion order is not maintained in a Hash set

Insertion order is maintained

Can contain duplicate elements

Cannot contain duplicate elements

Can contain duplicate elements.

Insertion and removal of an array can be done for any index.

Remove the specified element.

Only the last inserted element can be popped out. Also, the insertion of elements happens at the end.

General syntax.

List<String> list = new ArryList<String>();

General syntax.

HashSet<String> set = new HashSet<String>();

General syntax.

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

Example 1: A simple example of List Interface using ArrayList

import java.util.*; public class ListInterface{ public static void main(String args[]){ //Creating a List List<String> list=new ArrayList<String>(); //Adding elements in the List list.add("Ford"); list.add("Tata"); list.add("Mahindra"); list.add("Suzuki"); list.add("Honda"); //Iterating the List element using for-each loop for(String Vehicle:list) { System.out.println(Vehicle); } }




Example 2: A simple example of Set Interface using HashSet

import java.util.HashSet;

import java.util.Set;

public class SetInterface {

public static void main(String[] args) {

//creating set

Set<String> set = new HashSet<String>();

//Adding elements in the Set






//Iterating the Set element using for-each loop

for(String vehicle:set) {







MAP Interface

  • The Map interface is not the part of the collection framework

  • Objects are stored in form of key and value pairs known as entry

  • A duplicate key is not allowed but the value can be duplicated

  • Heterogeneous type of objects is allowed

  • Insertion order is not preserved

  • The important implementations of Map are HashMap, Treemap, LinkedHashMap, and HashTable.

Difference between HashMap, Treemap, LinkedHashMap, and HashTable:





Null keys and values are allowed

Key cannot be null, values can be null

Null keys and values are allowed.

It won’t allow null keys and values.

Not synchronized

Not synchronized

Not synchronized


There is no guarantee to maintain order in the iteration

Sorting will be done based on the natural order.

An Insertion order will be maintained

Insertion order not maintained.

Example: Basic program of map interface in Java

import java.util.HashMap;

class Main {

public static void main(String[] args) {

// create a hashmap

HashMap<String, Integer> languages = new HashMap<>();

// add elements to hashmap

languages.put("Java", 8);

languages.put("C", 11);

languages.put("C++", 9);

languages.put("Python", 5);

System.out.println("HashMap elements : " + languages);




 HashMap elements : {Java=8, C++=9, C=11, Python=5}

Frequently Asked Questions

#1) What is the use of a collection framework in Java?

Answer: The collection framework offers prepackaged algorithms, interfaces, and classes that allow programmers to write highly efficient programs that can store and process data.

#2) What is Java Collections API in Java?

Answer: The Java collections API provides interfaces and classes that can be extended and implemented in order to use data structures that are nothing but collections.


This blog gave us an introduction to the Java Collections Framework.

I hope this blog explained most of the topics in the Java collections framework, its hierarchy, interface, list, queue, and sets that I have discussed above. Please share your opinion with comments.

430 views0 comments