Collections Framework Overview

Before the Collections Framework, Java developers stored groups of objects in plain arrays or in ad hoc classes like Vector and Hashtable, each with its own inconsistent set of methods. The Java Collections Framework, introduced in Java 1.2, replaced that inconsistency with a single, unified architecture: a small set of interfaces that define what a data structure can do, and a rich set of implementing classes that define how it does it efficiently.

The core idea is separation of interface from implementation. Code written against the List interface works identically whether the underlying object is an ArrayList or a LinkedList, which means you can change the internal data structure later — for performance reasons — without touching the rest of your program.

Why it matters

Almost every Java program holds groups of objects: rows from a database, items in a cart, requests waiting to be handled. The Collections Framework gives all of these the same small set of interfaces, so choosing the right one is mostly a matter of answering three questions: does order matter, are duplicates allowed, and do you look things up by a key? Interviewers ask about collections more than any other part of the standard library.

The Interface Hierarchy

At the root sits the Iterable interface, which guarantees anything implementing it can be used in a for-each loop. Collection extends Iterable and is the parent of the three main branches used for storing individual elements. Map is deliberately kept separate, because it stores key-value pairs rather than single elements, and does not extend Collection.

• Collection → List (ordered, allows duplicates) → ArrayList, LinkedList, Vector
• Collection → Set (no duplicates) → HashSet, LinkedHashSet, TreeSet (via SortedSet/NavigableSet)
• Collection → Queue (FIFO-style processing) → LinkedList, PriorityQueue, and Deque → ArrayDeque
• Map (separate hierarchy, key-value pairs) → HashMap, LinkedHashMap, TreeMap, Hashtable

Why the Framework Exists

The framework gives every collection a predictable, shared vocabulary: methods like add(), remove(), contains(), and size() behave consistently across implementations, and generic algorithms in the Collections utility class (Collections.sort(), Collections.reverse(), Collections.max()) work on any List or Collection regardless of its concrete type. This is what lets you swap a HashMap for a TreeMap, or an ArrayList for a LinkedList, by changing one line of code.

Choosing the Right Collection

Picking a collection is really answering three questions: does order matter, are duplicates allowed, and do you need key-value lookup? A List preserves insertion order and allows duplicates; a Set forbids duplicates; a Map associates unique keys with values; a Queue/Deque models processing order (first-in-first-out, or double-ended). Choosing correctly up front avoids awkward workarounds later.

Example

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

public class FrameworkDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(); // could be swapped for LinkedList
        names.add("Asha");
        names.add("Ravi");
        names.add("Meera");

        printAll(names); // works identically for any List implementation

        List<String> linked = new LinkedList<>(names);
        printAll(linked);
    }

    static void printAll(List<String> list) {
        for (String name : list) {
            System.out.print(name + " ");
        }
        System.out.println();
    }
}

Asha Ravi Meera
Asha Ravi Meera

Exercise

The list below contains repeated names. Build a collection that holds each name once, in alphabetical order, then print how many distinct names there are and the collection itself.

Expected output: 3 then [Asha, Ravi, Zoya]

import java.util.List;

public class DistinctNames {
    public static void main(String[] args) {
        List<String> names = List.of("Ravi", "Asha", "Zoya", "Asha", "Ravi");

        // TODO: create a collection with no duplicates, kept in sorted order
        // TODO: print its size, then print the collection
    }
}

import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public class DistinctNames {
    public static void main(String[] args) {
        List<String> names = List.of("Ravi", "Asha", "Zoya", "Asha", "Ravi");

        Set<String> distinct = new TreeSet<>(names);

        System.out.println(distinct.size()); // 3
        System.out.println(distinct);        // [Asha, Ravi, Zoya]
    }
}

Quick quiz

Interview questions