Java Collections Framework Interview Questions

The Java Collections Framework is a set of interfaces and classes that provide data structures and algorithms for storing and manipulating groups of objects.

Collection is the root interface of the collection hierarchy, while Collections is a utility class that provides static methods for collection operations.

List allows duplicate elements and maintains insertion order, whereas Set does not allow duplicates.

ArrayList uses a dynamic array and provides fast random access, while LinkedList uses a doubly linked list and provides efficient insertion and deletion operations.

HashSet stores elements in an unordered manner using hashing, while TreeSet stores elements in sorted order using a tree structure.

HashMap is not synchronized and allows one null key and multiple null values, whereas Hashtable is synchronized and does not allow null keys or values.

ConcurrentHashMap is thread-safe and designed for concurrent access, while HashMap is not thread-safe.

HashMap stores key-value pairs in buckets using hash codes. It uses hashing and equals() methods to locate and retrieve values efficiently.

Load factor determines when a HashMap should resize. The default load factor is 0.75.

Hashing is the process of converting an object into an integer hash code used for efficient storage and retrieval.

A collision occurs when multiple keys generate the same bucket index. HashMap handles collisions using linked lists or balanced trees.

Fail-fast iterators throw ConcurrentModificationException when the collection is modified during iteration, while fail-safe iterators work on a copy and do not throw exceptions.

Comparable is an interface used to define the natural ordering of objects through the compareTo() method.

Comparator is an interface used to define custom sorting logic through the compare() method.

Custom objects can be sorted using Comparable for natural ordering or Comparator for custom ordering.

Name concrete APIs (collections, concurrency, streams, annotations) tied to Java Collections Framework. Interviewers want syntax-level clarity plus when you would reach for each feature in production.

Prefer specific checked/unchecked exceptions, wrap lower-level failures with context, and avoid empty catch blocks. For Java Collections Framework, decide what is recoverable vs fatal to the request thread.

JUnit 5 with Arrange-Act-Assert, Mockito for collaborators, and parameterized tests for edge cases. Keep Java Collections Framework logic pure where possible so tests stay fast.

Incorrect equals/hashCode break HashMap/HashSet behavior. If Java Collections Framework stores objects in collections, explain the contract and mutability pitfalls.

Retain only needed references, prefer streaming for large datasets, and avoid accidental caches. Relate leaks or GC pressure to a concrete Java Collections Framework scenario.