Collections Interview Questions

It is a group of interfaces, implementations, and algorithms for storing and processing groups of objects with type safety and reusable behavior.

A collection is an object that stores multiple elements as one unit, such as a list of employees or a set of IDs.

Collection is the root interface for List, Set, and Queue. Collections is a utility class that provides static methods for sorting, searching, reversing, and synchronized wrappers.

Collection stores individual elements. Map stores key-value pairs, has unique keys, and does not extend Collection.

The main interfaces are List, Set, Queue, Deque, and Map. They describe ordered values, unique values, processing queues, double-ended queues, and key-value associations.

Iterable is the parent of Collection, which branches into List, Set, and Queue. Map has a separate hierarchy with HashMap, LinkedHashMap, TreeMap, and concurrent implementations.

List preserves order and allows duplicates, Set stores unique values, and Map stores unique keys with associated values.

Generics provide compile-time type safety, remove most casts, improve readability, and prevent unrelated object types from entering a collection.

List is an ordered collection that permits duplicates, supports index-based access, and commonly allows null values.

ArrayList is a resizable-array List implementation suited to frequent reads, indexed access, and additions at the end.

ArrayList stores elements in an internal array. When it fills, a larger array is allocated and existing elements are copied.

An empty ArrayList commonly has no allocated storage until its first addition; standard implementations commonly allocate capacity 10 then. Treat this as implementation behavior, not a general API guarantee.

When full, it grows its internal array by an implementation-defined amount, commonly around 50 percent, and copies the existing values.

Indexed get and set are O(1), append is amortized O(1), while search and insertion or removal near the beginning are generally O(n).

LinkedList is a doubly linked implementation of List, Queue, and Deque. Each node holds a value and links to neighboring nodes.

ArrayList has fast indexed access and lower overhead. LinkedList supports operations at known ends or nodes but has slow traversal and extra node memory.

Prefer ArrayList for random access, iteration-heavy workloads, additions at the end, and most general application lists.

Use it when the abstraction is genuinely a deque or queue and operations occur at both ends. ArrayDeque is often a better stack or queue implementation.

Vector is a legacy synchronized resizable-array List. Modern code usually prefers ArrayList or a specific concurrent list implementation.

Stack is a legacy LIFO class. ArrayDeque is generally preferred for stack behavior because it is modern and avoids unnecessary synchronization.

Use List.of or an unmodifiable copy when a list must not be changed. List.of rejects null values.

Arrays.asList is fixed-size and backed by an array, allowing replacement. List.of is immutable and rejects null values.

Create a new ArrayList from Arrays.asList so structural changes are supported.

Set is a collection that prevents duplicate elements according to equality or ordering rules.

HashSet uses hashing for unique membership checks, provides average constant-time operations, has no order guarantee, and permits one null.

HashSet stores elements as keys in an internal HashMap with a shared dummy value. Map key uniqueness gives Set uniqueness.

It uses hashCode to select a bucket and equals to compare candidates. Correct custom objects must override both methods consistently.

LinkedHashSet provides unique values like HashSet while maintaining insertion order using linked ordering information.

TreeSet stores unique values in sorted order using natural ordering or a supplied Comparator. Operations are generally O(log n).

HashSet optimizes uniqueness without order, LinkedHashSet preserves insertion order, and TreeSet maintains sorted order with tree-based operations.

Yes. HashSet permits one null value because duplicate null additions are ignored.

TreeSet compares elements to maintain order, and null normally cannot be compared with non-null values.

Map stores key-value pairs. Keys are unique, while values may be duplicated.

HashMap is a hash-based Map that provides average constant-time lookup, permits one null key and multiple null values, and is not thread-safe.

HashMap hashes a key, selects a bucket, compares existing keys with equals, and adds or replaces an entry. Collision-heavy buckets may use tree structures.

A collision occurs when different keys map to the same bucket. HashMap stores and compares colliding entries using equality.

The new value replaces the old value and the map size does not increase.

Yes. HashMap permits one null key and any number of null values.

Changing fields used by hashCode or equals after insertion can move the logical key to a different bucket and make it unreachable.

Equal objects must return the same hash code. Equal hash codes do not necessarily mean objects are equal, and equality-related state should remain stable.

Hash-based collections can place equal objects in different buckets, causing duplicate logical values and failed lookup or removal.

LinkedHashMap is a HashMap with predictable insertion order, or access order when configured for cache-like behavior.

Yes. Its accessOrder constructor option moves accessed entries toward the end and can support an LRU cache.

TreeMap stores keys in sorted order using a balanced tree and supports range and navigation operations in O(log n).

HashMap provides fast unordered lookup, LinkedHashMap preserves insertion or access order, and TreeMap sorts keys with logarithmic operations.

Hashtable is a legacy synchronized Map that rejects null keys and values. Modern code generally uses ConcurrentHashMap for concurrent access.

HashMap is unsynchronized and permits nulls. Hashtable synchronizes methods, rejects nulls, and is a legacy implementation.

ConcurrentHashMap is a scalable thread-safe Map that supports concurrent reads, updates, and atomic operations without one global application lock.

A null result from get would be ambiguous: it could mean absent or present with null. Rejecting null removes that ambiguity.

HashMap is not thread-safe and permits nulls. ConcurrentHashMap supports concurrent mutation, rejects nulls, and provides weakly consistent iterators.

Use entrySet when both keys and values are needed, or Map.forEach for concise iteration.

keySet exposes keys, values exposes values, and entrySet exposes key-value pairs. Use entrySet when both are required.

Queue represents elements waiting for processing, commonly in FIFO order, with operations such as offer, poll, peek, add, and remove.

Both insert into a queue. add may throw when insertion fails, while offer returns false and is safer for capacity-restricted queues.

Both remove the head. remove throws when empty, while poll returns null.

Both inspect the head without removing it. element throws when empty, while peek returns null.

PriorityQueue removes elements according to priority rather than insertion order. Its default priority is the smallest natural value.

Deque is a double-ended queue that supports adding and removing from both the front and back.

ArrayDeque is modern, efficient, supports both stack and queue operations, and avoids legacy Stack synchronization overhead.

Iterator traverses collection elements using hasNext and next and can safely remove the current element with iterator.remove.

Calling collection.remove during enhanced-for iteration can cause ConcurrentModificationException. Iterator.remove coordinates removal with traversal.

ListIterator is a list-specific iterator supporting forward and backward traversal, replacement, insertion, removal, and index queries.

Iterator supports broad forward traversal and removal. ListIterator works only with lists and also supports backward traversal, add, set, and indexes.

It may throw ConcurrentModificationException when it detects structural modification outside the iterator. This is a best-effort bug detector, not thread safety.

Fail-safe is an informal term for snapshot or concurrent iterators that continue without immediately throwing on concurrent changes. Weakly consistent is more precise.

Fail-fast iterators may report structural modification. Weakly consistent iterators tolerate concurrent changes and may reflect some, all, or none of them.

Use Collections.sort, List.sort, or a Comparator. Comparator.reverseOrder provides descending natural order.

Comparable defines a type’s natural ordering through compareTo and is implemented by the class being sorted.

Comparator defines an external ordering strategy. Multiple comparators can sort the same class by different fields.

Comparable provides one natural order through compareTo. Comparator provides reusable external orders through compare and does not require changing the class.

Chain comparators with thenComparing so a secondary field is used when the primary values are equal.

Use Comparator.nullsFirst or nullsLast around the real comparator.

They are collections designed for safe, scalable multi-threaded access, including ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, and concurrent queues.

It copies its backing array on each modification and is suitable for read-heavy, write-rare workloads with snapshot-style iteration.

BlockingQueue supports producer-consumer workflows by waiting when taking from empty queues or adding to full bounded queues.

Synchronized wrappers commonly use one collection-level lock. Concurrent collections use specialized algorithms and atomic operations for better scalability.

Use stream.filter with a predicate and collect or toList the matching values.

Use distinct, which relies on equality semantics, then collect the stream result.

Use Collectors.toMap with key and value functions, and provide a merge function when duplicate keys are possible.

Use Collectors.groupingBy with a classifier such as department or status.

Group by the element and use Collectors.counting as the downstream collector.

Use HashSet for fast uniqueness, LinkedHashSet when insertion order matters, or TreeSet when sorted order is required.

Use a Map with the employee ID as the key and Employee as the value.

Use LinkedHashSet.

Use TreeSet.

Use LinkedHashMap configured with access order and override removeEldestEntry, or use a dedicated cache library for production needs.

Use BlockingQueue, such as LinkedBlockingQueue or ArrayBlockingQueue.

Use CopyOnWriteArrayList when reads dominate, writes are rare, and snapshot iteration is acceptable.

Use ConcurrentHashMap for concurrent key-value access. A dedicated cache library may be better for eviction, expiration, and statistics.

No. Collections store objects, so use wrapper types such as Integer instead of int. Java provides autoboxing and unboxing.

For List<Integer>, remove(int) selects an index. Use remove(Integer.valueOf(value)) to select the value overload.

Structural modification during iteration may throw ConcurrentModificationException. Prefer removeIf, an iterator, or a concurrent collection.

If equality-related fields change, contains or remove may fail because the object is now associated with a different hash location.

Yes. Keys must implement Comparable or TreeMap must receive a Comparator.

Sorted collections treat the objects as equal for ordering, so TreeSet may keep one and TreeMap may replace a value.

No. Use LinkedHashMap for insertion or access order and TreeMap for sorted key order.

Concurrent reads can be safe only after safe publication and when no thread mutates the map. Use an immutable map or ConcurrentHashMap for shared concurrent access.

Load factor controls how full the table becomes before resizing. The common default is 0.75, balancing memory and collisions.

Capacity is the number of internal buckets, while size is the number of entries. The common default capacity is 16 when storage initializes, but implementations may vary.

It resizes the bucket array, redistributes entries, and continues with a larger capacity. Providing a suitable initial capacity can reduce expensive resizing.

ArrayList provides O(1) indexed access, hash collections average O(1) lookup, tree collections O(log n), and queue priority operations commonly O(log n). Always measure realistic workloads.

Program to interfaces, use generics, choose by access and ordering needs, prefer immutable values, implement equals and hashCode correctly, avoid unsafe modification, and use concurrent types for shared state.