Java Collections Framework Notes

What is Java Collections Framework?

Basic Idea

JCF gives you ready-made ways to store and manage collections (groups) of objects. It includes rules (interfaces), actual tools (classes), helpful methods (algorithms), and extra helpers.

Parts of JCF

• Interfaces: Like blueprints that say what a collection can do (e.g., List for ordered items)
• Implementations(classes): Real classes that follow those blueprints (e.g., ArrayList is a type of List)
• Algorithms: Ready functions to sort, search, or mix up items (in classes like Collections)
• Support Classes: Things like iterators (to loop through items) or comparators (to sort)

Why Use It?

• Saves time: No need to make your own data structures
• Fast and safe: Built-in speed and checks for errors
• Works together: Easy to switch between different types

Key Features

• Collections can grow or shrink (except fixed ones like arrays)
• Holds objects (numbers like int become Integer automatically)
• Since Java 5, uses "generics" for type safety (e.g., only strings in a list of strings)

Main Roots

• Collection interface: For most collections (not maps)
• Map interface: For key-value pairs

Core Interfaces (Blueprints)

Interfaces define what you can do with collections. They build on each other.

Concrete Implementations (Real Classes)

These are the actual tools you use. Here are the main classes organized by type:

List Classes

Set Classes

Queue/Deque Classes

Map Classes

Iterators and Looping

• Iterator: Tool from iterator() to go through items one by one.
  • Actions: hasNext() (more items?), next() (get next), remove() (delete last got)
  • Fail-fast: Errors if you change collection while looping (except with remove())
  • Limitation: Can only move forward, not backward
• ListIterator: For lists, can go both forward and backward.
  • Extra: hasPrevious(), previous(), add(), set()
  • Note: Only available for List classes (ArrayList, LinkedList, etc.)
• Spliterator: (Java 8+) Designed for parallel processing.
  • Used internally in Streams API
  • Can split tasks across multiple threads
  • Supports bulk operations like trySplit(), forEachRemaining()
• Enhanced For-Loop: Easy syntax: for (String s : list)
  • Internally uses Iterator
  • Readable, but cannot remove elements while looping
• Fail-Fast vs Fail-Safe:
  • Fail-Fast: Throws ConcurrentModificationException if collection is modified (e.g., ArrayList, HashSet).
  • Fail-Safe: Works on a copy (snapshot), no error if modified (e.g., CopyOnWriteArrayList, ConcurrentHashMap).

Comparators and Sorting

• Comparable: - Interface inside java.lang.
  - Used when a class defines its natural ordering (like A–Z for Strings, ascending for Numbers).
  - Method: int compareTo(T o) → returns negative, zero, or positive.
• Comparator: - Interface inside java.util.
  - Used when we want custom sorting rules outside the class.
  - Method: int compare(T o1, T o2).

import java.util.*;

// ✅ Example 1: Using Comparable (natural order)
class Student implements Comparable {
    int id;
    String name;
    Student(int id, String name) {
        this.id = id; this.name = name;
    }
    // Natural order: by id (ascending)
    public int compareTo(Student other) {
        return this.id - other.id;
    }
    public String toString() { return id + "-" + name; }
}

// ✅ Example 2: Using Comparator (custom order)
class NameComparator implements Comparator {
    public int compare(Student s1, Student s2) {
        return s1.name.compareTo(s2.name); // sort by name
    }
}

public class Main {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(new Student(3, "Deepak"));
        list.add(new Student(1, "Tushar"));
        list.add(new Student(2, "Shreeram"));

        // 🔹 Natural sort (Comparable → by id)
        Collections.sort(list);
        System.out.println("Sorted by ID (Comparable): " + list);

        // 🔹 Custom sort (Comparator → by name)
        Collections.sort(list, new NameComparator());
        System.out.println("Sorted by Name (Comparator): " + list);

        // 🔹 Even shorter using lambda Comparator
        list.sort((a, b) -> b.id - a.id);
        System.out.println("Sorted by ID Desc (Lambda Comparator): " + list);
    }
}

Utility Classes (Helpers)

1. Collections Class

Static helpers:

• sort(List list): Sort naturally
• sort(List list, Comparator c): Custom sort
• binarySearch(List list, Object key): Find in sorted list
• reverse(List), shuffle(List), swap(List, i, j)
• unmodifiableCollection(Collection c): Make read-only
• synchronizedCollection(Collection c): Make thread-safe
• checkedCollection(Collection c, Class type): Extra type checks
• emptyList(), singleton(item): Small fixed collections

2. Arrays Class

For plain arrays:

• sort(array), binarySearch(array, key)
• asList(items...): Turn array to list (fixed size)
• fill(array, value), copyOf(array, length)

Generics in Collections

• Old Way (Before Java 5): No types, like List list = new ArrayList(); – can mix types, errors at run time
• New Way: List<String> list = new ArrayList<>(); – Only strings, checks at compile
• Wildcards: ? (any), ? extends Type (subtypes), ? super Type (supertypes) for flexibility

Concurrency and Thread-Safety

Fixes:

• 1. Wrappers (Synchronized Collections): Use Collections.synchronizedXXX() to make existing collections thread-safe.
  Example: Collections.synchronizedList(new ArrayList<>())
  • Simple and easy to use
  • Whole collection is locked → slower for high concurrency

  Meaning of XXX

  • synchronizedList() → makes a List thread-safe
  • synchronizedSet() → makes a Set thread-safe
  • synchronizedMap() → makes a Map thread-safe
  • synchronizedCollection() → makes a generic Collection thread-safe
• 2. Concurrent Collections: Classes in java.util.concurrent are designed for multi-threading.
  Examples:
  • ConcurrentHashMap: Thread-safe HashMap (no full lock, faster)
  • CopyOnWriteArrayList: Thread-safe List (good for more reads than writes)
  • CopyOnWriteArraySet: Thread-safe Set
  • BlockingQueue (e.g., ArrayBlockingQueue, LinkedBlockingQueue): For producer-consumer pattern

Explanation:

- Use synchronized wrappers for small, simple multi-threaded tasks.
- Use concurrent collections for servers, thread pools, or real-time systems where many threads read/write data at the same time.
- Fail-Fast Iterators throw errors if modified during iteration, while Fail-Safe Iterators (in concurrent collections) work on a snapshot and don’t throw errors.

Examples:

// ✅ Example 1: Synchronized Map
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, String> safeMap = Collections.synchronizedMap(new HashMap<>());
        safeMap.put("A", "Apple");
        safeMap.put("B", "Banana");

        synchronized (safeMap) { // Must lock while iterating
            for (String key : safeMap.keySet()) {
                System.out.println(key + " → " + safeMap.get(key));
            }
        }
    }
}

// ✅ Example 2: ConcurrentHashMap (no need to lock manually)
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<Integer, String> cmap = new ConcurrentHashMap<>();
        cmap.put(1, "Deepak");
        cmap.put(2, "Shreeram");
        cmap.put(3, "Tushar");

        // Multiple threads can safely access without explicit sync
        cmap.forEach((id, name) -> System.out.println(id + " → " + name));
    }
}

// ✅ Example 3: CopyOnWriteArrayList (safe iteration even with updates)
import java.util.concurrent.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String s : list) {
            System.out.println(s);
            list.add("D"); // No error, works safely
        }
        System.out.println("Final List: " + list);
    }
}

Advanced Topics

• Hashing Inside: HashMap uses buckets (lists in array), turns to trees if too full for speed
• Capacity/Load: HashMap starts at 16, grows at 75% full
• Views: keySet() is live – changes affect map
• Old Classes: Vector/Hashtable/Stack – Skip for new code
• Custom: Extend AbstractList/etc. for your own
• Tuning: Set start size: new HashMap(100) to avoid growing

Interview Questions and Tips

Common Interview Questions

Tips for Interviews