Java Collections Framework

The Java Collections Framework is Java's toolbox for storing groups of objects: lists, sets, queues, and maps. Instead of building your own data structures, you pick a tested one like ArrayList or HashMap. This guide walks through the collection hierarchy, what each interface is for, and how to choose the right one.

What is the Collections Framework?

It's a set of interfaces (what a collection can do) and classes (how it does it) in the java.util package. Think of a kitchen: you have a cutlery tray (ordered slots), a spice rack (one of each), and labelled jars (look up by name). Each container suits a different job.

The Java collection hierarchy

Everything is built on interfaces, so your code can depend on a type of collection (like List) rather than a specific class (like ArrayList):

The core collection interfaces

Which collection should I use?

Start from what you need, not from the class names. Pick a need below:

List<String> cart = new ArrayList<>();
cart.add("Milk");
cart.add("Milk");   // duplicates allowed

Set<String> tags = new HashSet<>();
tags.add("java");
tags.add("java");   // ignored, already present

Map<String, Integer> stock = new HashMap<>();
stock.put("apples", 12);
stock.get("apples");   // 12

Deque<String> jobs = new ArrayDeque<>();
jobs.offer("print A");
jobs.offer("print B");
jobs.poll();   // "print A"

Comparing the main implementations

Let's see it in action

Here's one small program using a List, a Set, and a Map together, counting words in a sentence:

import java.util.*;

public class WordStats {
    public static void main(String[] args) {
        List<String> words = List.of("the", "cat", "sat", "on", "the", "mat");

        Set<String> unique = new TreeSet<>(words);          // removes duplicates, keeps sorted
        Map<String, Integer> counts = new TreeMap<>();
        for (String w : words) {
            counts.merge(w, 1, Integer::sum);               // add 1 to this word's count
        }

        System.out.println("All words:    " + words);
        System.out.println("Unique words: " + unique);
        System.out.println("Counts:       " + counts);
    }
}

All words:    [the, cat, sat, on, the, mat]
Unique words: [cat, mat, on, sat, the]
Counts:       {cat=1, mat=1, on=1, sat=1, the=2}

• List.of(...) — a quick, unmodifiable list.
• new TreeSet<>(words) — copies the words into a sorted set, so the duplicate "the" disappears.
• counts.merge(w, 1, Integer::sum) — "put 1 if the word is new, otherwise add 1 to what's there".

Tip: declare variables with the interface type

List<String> names = new ArrayList<>();     // ✔ preferred
ArrayList<String> names2 = new ArrayList<>();  // works, but ties your code to one class

If you later need a different list implementation, you change one word, and the rest of the code keeps working. The <String> part is a generic type; it tells Java the collection holds Strings, so the compiler stops you from adding anything else.

Helpful utilities: Collections and factory methods

• List.of(...), Set.of(...), Map.of(...) — create small unmodifiable collections in one line (Java 9+).
• Collections.sort(list), Collections.reverse(list), Collections.max(c) — static helpers in the Collections utility class. Note the plural "s".
• Collections.unmodifiableList(list) — a read-only view of an existing list.

Quick recap

What's next?

Get hands-on with the most-used collection in Java ArrayList (and how to sort it), then learn to share lists safely between threads in thread-safe lists.