Corporate Training
Request Demo
Click me
Let's Talk
Request Demo


Collections Framework (ArrayList, HashMap, etc.)

15. Collections Framework (ArrayList, HashMap, etc.)

The Java Collections Framework is a powerful set of classes and interfaces that provide a unified, high-level way to work with collections of objects. Collections allow you to store, manipulate, and retrieve data efficiently. In this Core Java tutorial, we'll explore some of the key components of the Collections Framework, including ArrayList, HashMap, and HashSet, with explanations and examples.


'ArrayList' is a dynamic array that can grow or shrink in size as needed. It's one of the most commonly used collection classes for storing and manipulating lists of objects.

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        // Creating an ArrayList of Strings
        List fruits = new ArrayList<>();

        // Adding elements

        // Accessing elements
        System.out.println("First fruit: " + fruits.get(0));

        // Iterating through elements
        for (String fruit : fruits) {

In this example, we create an 'ArrayList' of strings, add elements, access elements by index, and iterate through the list.


'HashMap' is a key-value pair collection that allows you to store and retrieve data based on a unique key. It's widely used for fast and efficient data retrieval.

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // Creating a HashMap of student names and their ages
        Map students = new HashMap<>();

        // Adding key-value pairs
        students.put("Alice", 25);
        students.put("Bob", 30);
        students.put("Eve", 22);

        // Accessing values by key
        int bobAge = students.get("Bob");
        System.out.println("Bob's age: " + bobAge);

        // Iterating through key-value pairs
        for (Map.Entry entry : students.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue() + " years old.");

In this example, we create a 'HashMap' of student names and their ages, add key-value pairs, access values by key, and iterate through the key-value pairs.


'HashSet' is an unordered collection that stores unique elements. It's commonly used when you need to maintain a set of distinct values.

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        // Creating a HashSet of integers
        Set numbers = new HashSet<>();

        // Adding elements

        // Adding a duplicate element (ignored)

        // Iterating through elements
        for (int number : numbers) {

In this example, we create a 'HashSet' of integers, add elements (including a duplicate, which is ignored), and iterate through the unique elements.

Collections Framework Interfaces:

The Collections Framework provides various interfaces, such as 'List', 'Set' ,  'Map', etc., that define common behaviors for collections. Classes like 'ArrayList', 'HashSet', and 'HashSMap'  implement these interfaces.

Here are some key interfaces:

  • 'List': Ordered collection with duplicates allowed.
  • 'Set': Unordered collection with no duplicates.
  • 'Map': Key-value pair collection.
  • 'Queue': A collection that represents a queue (FIFO).

Using Generics:

You may have noticed that we used generics (e.g.,  'List<String>', 'Map<String','Integer>') when declaring collections. Generics allow you to specify the type of objects that a collection can hold, providing type safety and eliminating the need for explicit type casting.


The Java Collections Framework is a powerful tool for managing and manipulating collections of data in Java. Understanding how to use ArrayList, HashMap, HashSet, and other collection classes, along with their respective interfaces and generics, is essential for effective Java programming. Collections simplify the process of working with data structures, making your code more readable, efficient, and maintainable.