Collections Framework: Overview

The Java Collections Framework (JCF) is a set of interfaces, classes, and algorithms in the java.util package that provide ready-made ways to store, retrieve, and manipulate groups of objects.

In simple words:

Collections = Ready-made data structures (list, set, queue, map) with common methods

Real-Life Example: Containers

Different situations need different containers:

1Shopping list       → order matters, duplicates allowed    → List
2Unique ID cards     → no duplicates                        → Set
3Queue at a ticket counter → first in, first out            → Queue
4Phone contacts      → name → number (key-value)            → Map

Java gives a ready-made container for each need, so you do not have to build them yourself.

Why Collections? (Problems with Arrays)

Collection Hierarchy

Click to zoom

Points to notice:

The Iterable Interface (Top of the Hierarchy)

Iterable is the root. Any class that implements it can be used in the for-each loop.

The Collection Interface: Common Methods

These methods are available in every List, Set, and Queue.

Methods That Are NOT in Collection

Each sub-interface adds its own methods.

The Map Interface (Separate Hierarchy)

Map stores key-value pairs. Keys are unique, values can repeat.

import java.util.*;

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

        students.put(1, "Ravi");
        students.put(2, "Anita");
        students.put(1, "Kiran");   // same key: old value is replaced

        System.out.println(students);              // {1=Kiran, 2=Anita}
        System.out.println(students.get(2));       // Anita
        System.out.println(students.containsKey(1)); // true
        System.out.println(students.keySet());     // [1, 2]
        System.out.println(students.values());     // [Kiran, Anita]
    }
}

Since Map is not a Collection, you can get a collection view of it using keySet(), values(), or entrySet().

Iterating Over Collections

1. For-each Loop

for (String fruit : fruits) {
    System.out.println(fruit);
}

2. Iterator

Iterator<String> it = fruits.iterator();

while (it.hasNext()) {
    String fruit = it.next();
    System.out.println(fruit);
}

3. forEach with Lambda (Java 8+)

fruits.forEach(fruit -> System.out.println(fruit));
fruits.forEach(System.out::println);   // method reference

Safe Removal While Iterating

Removing from a collection inside a for-each loop throws ConcurrentModificationException (this is called fail-fast behavior).

//  Wrong
for (String f : fruits) {
    if (f.equals("Apple")) {
        fruits.remove(f);   // ConcurrentModificationException
    }
}

// Correct: Iterator.remove()
Iterator<String> it = fruits.iterator();
while (it.hasNext()) {
    if (it.next().equals("Apple")) {
        it.remove();
    }
}

// Correct: removeIf()
fruits.removeIf(f -> f.equals("Apple"));

Generics in Collections

Generics make collections type safe, so the compiler catches wrong types and no casting is needed.

// Without generics (old style): risky
List list = new ArrayList();
list.add("Hello");
list.add(100);
String s = (String) list.get(1);   // ClassCastException at runtime

// With generics: safe
List<String> names = new ArrayList<>();
names.add("Hello");
// names.add(100);   //  Compile-time error

Collections store objects only, so primitives use wrapper classes:

1List<int>       Not allowed
2List<Integer>   Correct

Ordering Terms Explained

"Ordered" and "sorted" are not the same. Ordered means insertion order. Sorted means arranged by value.

The Collections Utility Class

Collections (with an "s") is a class with static helper methods. It is different from the Collection interface.

List<Integer> nums = new ArrayList<>(List.of(30, 10, 20));

Collections.sort(nums);                       // [10, 20, 30]
Collections.reverse(nums);                    // [30, 20, 10]
Collections.shuffle(nums);                    // random order
System.out.println(Collections.max(nums));    // 30
System.out.println(Collections.min(nums));    // 10
System.out.println(Collections.frequency(nums, 10)); // 1

List<Integer> fixed = Collections.unmodifiableList(nums);   // read-only view

Sorting: Comparable vs Comparator (Preview)

TreeSet, TreeMap, and PriorityQueue use these to decide the order. We will cover them in detail later.

Legacy Classes (Avoid in New Code)

Thread Safety (Preview)

Most collections (ArrayList, HashSet, HashMap) are not thread-safe. For multi-threaded programs, use:

How to Choose a Collection

1Need key-value pairs?                      → Map
2   Need sorted keys?                       → TreeMap
3   Need insertion order?                   → LinkedHashMap
4   Just fast lookup?                       → HashMap
5 
6Need unique elements?                      → Set
7   Need sorted?                            → TreeSet
8   Need insertion order?                   → LinkedHashSet
9   Just fast lookup?                       → HashSet
10 
11Need duplicates and index access?          → List
12   Mostly reading by index?                → ArrayList
13   Frequent insert/delete at the ends?     → LinkedList / ArrayDeque
14 
15Need FIFO / LIFO processing?               → Queue / Deque (ArrayDeque)
16Need highest/lowest priority first?        → PriorityQueue

Key Benefits

Programming to an Interface

A good habit is to declare the variable using the interface type, so you can change the implementation later without changing the rest of the code.

List<String> names = new ArrayList<>();   // ✅ interface on the left
// later: names = new LinkedList<>();       // only one line changes

ArrayList<String> names2 = new ArrayList<>();   // ❌ tied to ArrayList

Interview Definition

The Java Collections Framework is a unified architecture of interfaces, implementation classes, and algorithms in the java.util package for storing and manipulating groups of objects, with Collection and Map as its two root interfaces.

Remember

Collection → List, Set, Queue (common methods live here). Map is separate and stores key-value pairs. Collections is only a utility class.