Java Collections Framework

Learning outcome: Explain the Java Collections Framework, choose suitable collection abstractions, use generics, and traverse elements safely with enhanced for loops and iterators.

Programs frequently need to store a group of related objects: student names, product records, task IDs, or marks. Arrays can hold several values, but their length is fixed. The Java Collections Framework provides reusable interfaces, implementations, and algorithms for groups that may grow, shrink, search, sort, and change while a program runs.

What Is a Collection?

A collection is an object that groups multiple elements into a single unit so that they can be stored, accessed, and processed together.

In simple terms: A collection is a container object. Instead of declaring fifty separate variables for fifty marks, keep one container and put all fifty marks inside it. The container itself knows how to add, count, search, and remove items.

In Java, Collection<E> is the root interface for most element-based containers in the Java Collections Framework. It defines common operations such as adding, removing, searching, and traversing elements. Interfaces such as List<E>, Set<E>, and Queue<E> extend Collection<E>. Map<K,V> belongs to the framework but has a separate hierarchy because it stores key-value associations rather than individual elements.

Collection<String> names = new ArrayList<>();

Here, Collection<String> is the interface type, ArrayList<String> is the implementation, and each stored element is a String.

Why Collections Are Needed

An array is a good choice when the number of elements is known and fixed. A collection is usually better when the program needs flexible size or higher-level operations.

For example, an ArrayList<Integer> can store integer values through the Integer wrapper class and can expand as values are added.

In simple terms: An array is a fixed row of chairs. Once thirty chairs are set out, the thirty-first guest has nowhere to sit. A collection is a row where staff keep adding chairs as guests arrive.

Framework, Interface, and Implementation

A framework is a coordinated set of interfaces and classes designed to solve a family of problems. In the Collections Framework:

• Interfaces describe the behaviour a data structure offers.
• Implementations provide the actual storage strategy.
• Algorithms perform reusable operations such as sorting or searching.

List<String> names = new ArrayList<>();

Here, List is the interface and ArrayList is the implementation. Declaring the variable with the interface type keeps the code flexible.

In simple terms: The interface is the menu: it lists what can be ordered. The implementation is the kitchen: it decides how the dish is actually prepared. Because the rest of the program only reads the menu, the kitchen can be changed from ArrayList to LinkedList without touching any other line.

Collection Hierarchy

The simplified hierarchy shows the most frequently used abstractions:

Iterable<E> sits above Collection<E>. It supplies iterator() and makes the enhanced for loop possible.

Collection and Collections Are Different

The names look similar but represent different ideas.

In simple terms: Collection (singular) is the thing that holds data. Collections (plural, with an s) is a toolbox of ready-made helper methods that operate on such things. One is a noun; the other is a set of tools.

List<Integer> scores = new ArrayList<>();
scores.add(72);
scores.add(91);
scores.add(84);

Collections.sort(scores);
System.out.println(scores);

Output:

[72, 84, 91]

Generics and Type Safety

Generics specify the type of element a collection can hold.

List<String> cities = new ArrayList<>();
cities.add("Chandigarh");
cities.add("Mohali");

The compiler prevents an unrelated value from being added:

// cities.add(42);  // compile-time error

Without generics, code would need manual casts and could fail at runtime. Prefer parameterized forms such as List<String> instead of raw forms such as List.

In simple terms: <String> is a label on the box reading "strings only". The compiler reads that label and rejects a wrong item immediately, so no surprise ClassCastException appears later while the program is running.

Core Collection Operations

Most collection implementations inherit a common vocabulary from Collection<E>.

Some collection objects are unmodifiable. Their update methods throw UnsupportedOperationException.

List<String> fixed = List.of("Java", "SQL", "Git");
System.out.println(fixed.contains("Java"));
// fixed.add("HTML");  // UnsupportedOperationException

Output:

true

In simple terms: List.of(...) produces a read-only list, like a printed notice board. Reading is allowed; writing is not. To edit it, first copy it with new ArrayList<>(fixed).

Iterating over a Collection

Enhanced for Loop

Use the enhanced for loop when each element only needs to be read.

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

public class CourseList {
    public static void main(String[] args) {
        List<String> courses = new ArrayList<>();
        courses.add("Java");
        courses.add("Database Systems");
        courses.add("Computer Networks");

        for (String course : courses) {
            System.out.println(course);
        }
    }
}

Output:

Java
Database Systems
Computer Networks

Iterator

An Iterator<E> provides a cursor-like way to move through a collection.

In simple terms: An iterator is a bookmark. hasNext() asks "is there another page?", next() turns to it and hands it over, and remove() tears out the page just read. Because the bookmark and the collection stay in step, this is the safe way to delete while traversing.

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

public class IteratorDemo {
    public static void main(String[] args) {
        List<Integer> marks = new ArrayList<>(List.of(92, 38, 75, 29));
        Iterator<Integer> iterator = marks.iterator();

        while (iterator.hasNext()) {
            if (iterator.next() < 40) {
                iterator.remove();
            }
        }

        System.out.println(marks);
    }
}

Output:

[92, 75]

Removing through the iterator is safer than structurally changing the same collection directly during iteration.

Why not just call marks.remove(...) inside the loop? The collection would change underneath the iterator, and the next call usually throws ConcurrentModificationException. iterator.remove() keeps both in step; removeIf does the same job in one line.

Bulk Operations

Bulk methods express set-like changes clearly.

In simple terms: retainAll keeps only the items present in both collections, that is, the overlap. Here it answers the question "which enrolled students actually submitted?"

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

public class BulkOperations {
    public static void main(String[] args) {
        List<String> enrolled = new ArrayList<>(
                List.of("Aman", "Diya", "Kabir", "Meera"));
        List<String> submitted = List.of("Diya", "Meera", "Zoya");

        enrolled.retainAll(submitted);
        System.out.println(enrolled);
    }
}

Output:

[Diya, Meera]

Choosing the Right Abstraction

Ask what behaviour the program requires before choosing a class.

Program to the most general interface that expresses the requirement.

Common Mistakes

Practice

1. Create a collection of five city names and print them with an enhanced for loop.
2. Remove every negative value from a list by using removeIf.
3. Use retainAll to find names that appear in two lists.
4. Explain why Map needs two type parameters while Collection needs one.

Quick Check

Lecture Quiz

Summary

The Java Collections Framework combines interfaces, implementations, and algorithms for working with groups of objects. Collection is the main interface for lists, sets, and queues, while Map models key-value associations separately. Generics provide type safety, and Iterable and Iterator support controlled traversal.