Mastering the Java Collection Framework — From Lists to Maps

Java Collection Framework – Quick Reference and Practical Guide

When we start coding in Java, we often remember the logic but get stuck on the syntax of how to use certain classes in the Collection Framework. This section summarizes the most commonly used ones — HashMap and HashSet — with practical examples, traversal methods, and a list of key methods you’ll actually use.

1. HashMap in Java

A HashMap is part of the Java Collections Framework and is used to store data in key-value pairs.
It allows one null key and multiple null values, and it does not maintain insertion order.

Example: Creating and Traversing a HashMap

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

public class HashMapTraversal {
    public static void main(String[] args) {
        HashMap<String, Integer> studentScores = new HashMap<>();

        studentScores.put("Alice", 85);
        studentScores.put("Bob", 92);
        studentScores.put("Charlie", 78);

        for (Map.Entry<String, Integer> entry : studentScores.entrySet()) {
            String studentName = entry.getKey();
            Integer score = entry.getValue();
            System.out.println(studentName + ": " + score);
        }
    }
}

---

Commonly Used HashMap Methods

---

2. HashSet in Java

A HashSet is a collection that contains unique elements only. It is backed by a HashMap, meaning duplicates are automatically ignored.
HashSet does not maintain insertion order, and the iteration order may vary.

Example: Iterating through a HashSet

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

public class HashSetTraversal {
    public static void main(String[] args) {
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Cherry");

        Iterator<String> iterator = hashSet.iterator();
        System.out.println("Traversing using Iterator:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

---

Commonly Used HashSet Methods

3. ArrayList in Java

An ArrayList is a resizable array implementation of the List interface.
It maintains insertion order, allows duplicate elements, and provides random access to elements in constant time.

Example: Traversing an ArrayList

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        System.out.println("Using for-each loop:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Commonly Used ArrayList Methods

---

4. LinkedList in Java

A LinkedList is a doubly-linked list implementation of the List and Deque interfaces.
It maintains insertion order and allows both sequential access and queue-like operations.

Example: Traversing a LinkedList

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> cities = new LinkedList<>();
        cities.add("Pune");
        cities.add("Mumbai");
        cities.add("Delhi");

        System.out.println("Traversing LinkedList:");
        for (String city : cities) {
            System.out.println(city);
        }
    }
}

Commonly Used LinkedList Methods

---

5. TreeSet in Java

A TreeSet is a sorted set that stores elements in ascending order using a balanced tree (Red-Black Tree).
It does not allow duplicate elements.

Example: Traversing a TreeSet

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(30);
        numbers.add(10);
        numbers.add(20);

        System.out.println("Elements in ascending order:");
        for (Integer num : numbers) {
            System.out.println(num);
        }
    }
}

Commonly Used TreeSet Methods

---

6. TreeMap in Java

A TreeMap stores key-value pairs in sorted order of keys.
It’s implemented using a Red-Black Tree, and it does not allow null keys.

Example: Traversing a TreeMap

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(3, "Banana");
        map.put(1, "Apple");
        map.put(2, "Cherry");

        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " => " + entry.getValue());
        }
    }
}

Commonly Used TreeMap Methods

---

7. PriorityQueue in Java

A PriorityQueue is a queue where elements are ordered according to their natural order or a custom comparator.
By default, it functions as a min-heap.

Example: Using a PriorityQueue

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.add(40);
        pq.add(10);
        pq.add(30);

        while (!pq.isEmpty()) {
            System.out.println(pq.poll());
        }
    }
}

Commonly Used PriorityQueue Methods

---

8. Stack in Java

A Stack follows Last In, First Out (LIFO) order.
It extends Vector, though Deque is preferred in modern Java for stack operations.

Example: Using Stack

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("HTML");
        stack.push("CSS");
        stack.push("JavaScript");

        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

Commonly Used Stack Methods

---

9. Queue in Java

A Queue follows First In, First Out (FIFO) order.
It’s used for task scheduling or managing requests.

Example: Using Queue

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(10);
        queue.add(20);
        queue.add(30);

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }
}

Commonly Used Queue Methods

---

10. Deque in Java

A Deque (Double-Ended Queue) allows insertion and removal of elements from both ends.
It can function as both a stack and a queue.

Example: Using Deque

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        deque.addFirst("Front");
        deque.addLast("Back");

        System.out.println("Front: " + deque.removeFirst());
        System.out.println("Back: " + deque.removeLast());
    }
}

Commonly Used Deque Methods

---

Closing Thoughts

The Java Collection Framework provides powerful data structures that handle almost all common storage and manipulation needs.
Understanding their basic syntax and knowing when to use which — List for ordered data, Set for unique data, Map for key-value pairs, and Queue for sequential processing — can make your code cleaner and more efficient.