Java Collections Framework: A Complete Tutorial with Code Examples

What Is the Java Collections Framework?

The Java Collections Framework (JCF) is a unified architecture for representing and manipulating groups of objects. It provides ready-to-use data structures and algorithms, saving you from writing boilerplate code and helping you write cleaner, more efficient programs.

At its core, the framework consists of:

• Interfaces — abstract data types like List, Set, Map, and Queue
• Implementations — concrete classes like ArrayList, HashSet, and HashMap
• Algorithms — utility methods in the Collections class for sorting, searching, and shuffling

The Core Interfaces

List

A List is an ordered collection that allows duplicate elements. The most commonly used implementation is ArrayList.

List<String> languages = new ArrayList<>();
languages.add("Java");
languages.add("Python");
languages.add("Java"); // duplicates allowed
System.out.println(languages); // [Java, Python, Java]

Use LinkedList when you need frequent insertions and deletions at arbitrary positions.

Set

A Set stores unique elements only — no duplicates. HashSet offers O(1) average performance, while TreeSet keeps elements sorted.

Set<String> uniqueTags = new HashSet<>();
uniqueTags.add("java");
uniqueTags.add("oop");
uniqueTags.add("java"); // ignored — already present
System.out.println(uniqueTags.size()); // 2

Map

A Map stores key-value pairs. Keys must be unique, but values can repeat. HashMap is the go-to choice for most use cases.

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 87);
System.out.println(scores.get("Alice")); // 95

Queue & Deque

A Queue follows FIFO (First-In, First-Out) ordering. ArrayDeque is the recommended implementation for most queue and stack use cases.

Queue<String> taskQueue = new ArrayDeque<>();
taskQueue.offer("Task A");
taskQueue.offer("Task B");
System.out.println(taskQueue.poll()); // Task A

Choosing the Right Collection

Need	Best Choice
Ordered list with duplicates	ArrayList
Unique elements, fast lookup	HashSet
Unique elements, sorted order	TreeSet
Key-value pairs, fast access	HashMap
Key-value pairs, sorted keys	TreeMap
FIFO processing	ArrayDeque

Iterating Collections

You can iterate over any collection using the enhanced for-loop or Java 8+ streams:

// Enhanced for-loop
for (String lang : languages) {
    System.out.println(lang);
}

// Stream API
languages.stream()
         .filter(l -> l.startsWith("J"))
         .forEach(System.out::println);

Key Takeaways

• Use List when order and duplicates matter.
• Use Set when uniqueness is required.
• Use Map for key-value associations.
• Prefer interface types in variable declarations (e.g., List<String> over ArrayList<String>) for flexibility.
• Thread-safe alternatives exist: CopyOnWriteArrayList, ConcurrentHashMap, etc.

The Collections Framework is one of the most-used parts of the Java standard library. Getting comfortable with it will dramatically improve your productivity as a Java developer.