Java Java Collections Interview Questions

Collection → List (ArrayList, LinkedList), Set (HashSet, TreeSet), Queue; Map hierarchy separate (HashMap, TreeMap, ConcurrentHashMap).

Collection<Integer> col = Arrays.asList(1, 2, 3);
List<Integer> list = new ArrayList<>();
Set<Integer> set = new HashSet<>();
Map<String, Integer> map = new HashMap<>();

ArrayList uses dynamic array (fast random access, slow insertion/deletion), LinkedList uses doubly-linked nodes (slow access, fast insertion/deletion at ends).

ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
LinkedList<Integer> ll = new LinkedList<>();
ll.addFirst(1);
ll.addLast(2);

HashMap uses array of buckets; hash function determines bucket index, collisions resolved via linked lists or red-black trees (Java 8+) when threshold exceeded.

HashMap<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
Node node = map.getNode("a");
int index = hash("a") % capacity;

Set uses HashMap internally (each Set element is stored as a HashMap key with a dummy value), so Set operations inherit HashMap's O(1) average lookup performance.

Set<Integer> set = new HashSet<>();
Map<Integer, String> map = new HashMap<>();
set.add(1);
map.put(1, "one");
Set<Integer> mapKeys = map.keySet();

HashMap is an unsynchronized hash table implementation that uses buckets with chaining/open addressing for collision resolution. It allows null keys/values, operates in O(1) average time, and is not thread-safe; use ConcurrentHashMap for concurrent access.

HashMap<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
Integer val = map.get("a");
map.remove("b");

HashMap is unsynchronized and faster; Hashtable is synchronized (thread-safe) but slower; HashMap allows one null key/multiple null values, Hashtable doesn't allow nulls.

HashMap<String, Integer> hm = new HashMap<>();
hm.put("a", 1);
Hashtable<String, Integer> ht = new Hashtable<>();
ht.put("a", 1);
System.out.println(hm.get("a"));
System.out.println(ht.get("a"));

TreeSet maintains sorted order (O(log n) operations) using Red-Black tree; HashSet uses hash table for O(1) average operations without ordering.

TreeSet<Integer> ts = new TreeSet<>();
ts.addAll(Arrays.asList(3, 1, 2));
HashSet<Integer> hs = new HashSet<>();
hs.addAll(Arrays.asList(3, 1, 2));
System.out.println(ts);
System.out.println(hs);

Map doesn't extend Collection interface; it's a key-value structure with different iteration patterns (entrySet, keySet, values) rather than single-element containers.

Map<String, Integer> map = new HashMap<>();
map.put("key", 1);
Collection<Integer> values = map.values();
System.out.println(values);
System.out.println(map.keySet());

Collection hierarchy: Iterable → Collection → List/Set/Queue; List (ArrayList, LinkedList), Set (HashSet, TreeSet), Queue (PriorityQueue); Map is separate (HashMap, TreeMap).

Arrays are static data structures with fixed size allocated at creation; you must copy to a larger array for resizing, unlike dynamic structures.

ArrayList is dynamic, unsynchronized, faster; Vector is synchronized (thread-safe), slower, legacy class; ArrayList should be used for new code.

Vector is a synchronized, dynamic array similar to ArrayList but thread-safe; it's legacy and replaced by ArrayList with external synchronization when needed.

Java Collections include List (ArrayList, LinkedList), Set (HashSet, TreeSet), Queue (PriorityQueue), Map (HashMap, TreeMap), and utilities like Collections class.

HashMap is not thread-safe; use ConcurrentHashMap for concurrent access or Collections.synchronizedMap() for full synchronization.

Fail-fast means iterators throw ConcurrentModificationException if the collection is modified during iteration; it detects concurrent modifications.

Deque (Double Ended Queue) allows insertion/removal at both ends; implementations include ArrayDeque and LinkedList, useful for stacks and queues.

Hashtable is synchronized (thread-safe but slower), ConcurrentHashMap uses segment-based locking allowing concurrent reads/writes, making it more effective for multi-threaded scenarios with better performance.

List is an ordered, mutable collection allowing duplicates; Set is unordered and prevents duplicates; both are interfaces implemented by concrete classes.

Capacity is the internal array size of a List; not the same as size (number of elements),capacity is pre-allocated to reduce resizing overhead.

ArrayList increases capacity by 50% of current size (capacity = old capacity * 1.5) when it exceeds the current limit, using System.arraycopy() for migration.

ArrayList search requires linear iteration O(n) unless sorted, then use Collections.binarySearch() for O(log n) complexity.

No, objects aren't lost in HashMap; if you put a null key or null value, they're stored. However, if a key's hashCode/equals changes after insertion, retrieval may fail.

Java Collections are interfaces (List, Set, Map) and implementations (ArrayList, HashMap, HashSet) that provide data structure abstractions for storing and manipulating object groups efficiently.

List interface implementations include ArrayList (dynamic array), LinkedList (doubly-linked list), Vector (synchronized legacy), and Stack (LIFO).

HashMap bucket count increases by doubling when load factor (default 0.75) is exceeded; new capacity = old capacity * 2.

HashMap uses hashCode() to determine bucket index and equals() to resolve collisions; put() computes index and stores entry, get() retrieves using the same hash-based lookup.

Capacity is the current size of HashMap's internal bucket array; initial capacity is 16, and it resizes when load factor is exceeded.

HashMap has a default of 16 buckets initially; buckets store Entry objects (key-value pairs) in linked chains to handle hash collisions.

Use get(index) or iterator() for lookup; use remove(index) or remove(object) for deletion from Lists.

Iterate using Iterator, enhanced for-loop, forEach(Consumer), stream().forEach(), or Enumeration (legacy) depending on collection type.

HashSet is unordered with O(1) operations; LinkedHashSet maintains insertion order using a doubly-linked list, slower than HashSet due to extra overhead.

SET is a Collection interface for unordered, unique elements; implementations include HashSet (hash-based), TreeSet (sorted), and LinkedHashSet (insertion-ordered).

Implement Iterable interface or use arrays/Collections; allows using enhanced for-loop syntax with any custom collection.

No, HashMap allows only one null key and multiple null values; duplicate keys overwrite previous values silently.

Elements must be Comparable (implement Comparator) or natural ordering fails; TreeSet cannot store non-comparable objects.

No, TreeSet doesn't allow null values; throws NullPointerException due to compareTo() null checks in ordering.

List (ArrayList, LinkedList), Set (HashSet, TreeSet), Map (HashMap, TreeMap); Queue and Deque are specialized subtypes.

O(1) average case for lookup; O(n) worst case if hash collisions are severe; depends on hash function quality and load factor.

Doubly-linked list has next and previous pointers; singly-linked has only next; doubly allows bidirectional traversal with O(1) reverse access.

O(n) sequential access from head; middle element requires n/2 node traversals; LinkedList favors insertion/deletion over random access.

O(n) linear search; LinkedList lacks random access, requires traversal from head or tail.

O(1) average case for search via contains(); O(n) worst case; backed by HashMap internally.

O(n) linear time; must traverse nodes sequentially, no index-based direct access.

HashSet: Object instances with hashCode/equals; TreeSet: Comparable/Comparator objects for sorted ordering.

Java LinkedList is doubly-linked; maintains previous and next node references for bidirectional traversal.

LinkedHashMap maintains insertion order via doubly-linked list; extends HashMap with predictable iteration order.

Main JCF interfaces: Collection (List, Set, Queue), Map; implementations include ArrayList, HashSet, HashMap, LinkedList, PriorityQueue, TreeSet, TreeMap.

Collection is an interface for single-element collections; Collections is a utility class with static methods like sort(), reverse(), unmodifiableList() for collection operations.

CopyOnWriteArrayList and CopyOnWriteArraySet use fail-safe iteration by creating snapshots, avoiding ConcurrentModificationException during concurrent modifications.

Enumeration is legacy, unidirectional (hasMoreElements/nextElement), doesn't support removal; Iterator is newer, bidirectional with remove(), and preferred.

Iterable has iterator() method returning Iterator; Iterator has hasNext(), next(), remove(); Iterable enables for-each loops, Iterator does actual traversal.

for-each loop calls iterable.iterator() to get Iterator, then repeatedly calls hasNext() and next(); Iterable and Iterator work together to enable convenient traversal.

Iterator is unidirectional and works with any Collection; ListIterator is bidirectional, works only with List, and allows element modification during iteration.

It throws NoSuchElementException if there are no more elements; calling hasnext() first is mandatory to avoid this.

iterator.remove() safely removes the last element returned by next() and updates the underlying collection without causing ConcurrentModificationException.

It throws ConcurrentModificationException because the iterator detects structural modification of the collection that wasn't done through its own remove() method.

Use iterator.remove() instead of collection.remove(), or use CopyOnWriteArrayList, or synchronize the collection access, or use Java 8 streams.

Queue implements FIFO (First-In-First-Out) discipline via offer/poll operations.

Stack implements LIFO (Last-In-First-Out) discipline, or use Deque with push/pop methods.

ArrayList is unsynchronized and faster than the legacy synchronized Vector; Vector is now obsolete.

ArrayList is faster for random access O(1); LinkedList is faster for insertions/deletions at the beginning O(1) vs ArrayList O(n).

O(n) because LinkedList must traverse sequentially from head to find the element.

O(n) worst case when searching for the last element, though access is O(1).

O(1) at the end, but O(n) in the worst case when inserting at the beginning.

O(1) amortized at the end due to pre-allocated capacity; O(n) when inserting in the middle.

Elements shift left to fill the gap; size decreases by 1; remaining elements maintain relative order.

Create a new ArrayList with the desired range using removeAll() with a filtered subset, or use ArrayList.subList().clear() to remove a contiguous range efficiently.

Roughly 50% of current capacity when exceeding threshold; ArrayList grows by 1.5x of current size.

16-32 bytes per node (varies by JVM) for Node objects containing references and pointers, not just the byte value.

Approximately 16-32 bytes per element for internal Node structure (next/prev pointers + references), making storage inefficient for primitives.

1 byte for the primitive value; ArrayList stores references, so actual memory is higher due to object wrapper overhead.

Queue is single-ended (add at tail, remove at head); Deque is double-ended (add/remove at both ends), supporting both FIFO and LIFO operations.

Deque expands Queue; Queue is a single-ended interface, Deque adds bidirectional access.

LinkedList implements both because it efficiently supports both sequential (List) and bidirectional (Deque) operations without overhead.

Use descendingIterator() method which traverses the list backwards efficiently without indexed access.

Comparator interface allows you to define custom ordering for PriorityQueue elements.

Deque (via ArrayDeque) replaces Stack; it's faster, not synchronized, and follows modern collection design patterns.

IdentityHashMap uses reference equality (==) instead of equals() for key comparison, useful for identity-based lookups.

HashMap uses equals() and hashCode() for equality; IdentityHashMap uses == for reference comparison only.

WeakHashMap uses weak references for keys, allowing garbage collection when keys are no longer referenced elsewhere.

HashMap keeps strong references to keys; WeakHashMap uses WeakReference, enabling automatic removal of unreachable keys.

SortedMap maintains keys in sorted order (per comparator or natural ordering) affecting iteration order and enabling range queries like subMap().

O(1) average case for get/put; HashMap does NOT guarantee this,it's average case, not worst case.

Yes, HashMap can degenerate to O(n) even with different hashCodes if hash function produces many collisions; Java 8+ mitigates this with tree-based buckets.

byte[] uses reference-based hashCode() and equals(), not content-based, causing different arrays to be treated as different keys despite identical content.

O(n) worst case,when all keys hash to the same bucket (all collisions) or bucket contains a tree with many entries.

O(1) average case, O(n) worst case if the key's bucket has many collisions or contains a red-black tree with traversal overhead.

Typically 1-2 transitions: hash the key, find the bucket, then retrieve the entry (or traverse tree if present in Java 8+).

Usually 1 new object (the Node/Entry wrapper); 2 if key-value pair requires boxing for primitive types.

Triggered when size exceeds (capacity × loadFactor); new capacity is typically double the old, then all entries are rehashed.

initialCapacity sets the starting bucket count; loadFactor (default 0.75) is the threshold ratio of size to capacity triggering resize.

Yes, HashMap still works but degenerates to O(n) for all operations since all keys collide in the same bucket; Java 8+ trees mitigate this somewhat.

Use Collections.sort(map.keySet()) or stream with map.keySet().stream().sorted().collect(Collectors.toList()); for sorting keys.

Use Collections.sort(new ArrayList<>(map.values())) or map.values().stream().sorted().collect(Collectors.toList()); for sorting values.

Use map.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(...) or Collections.sort(new ArrayList<>(map.entrySet()), Map.Entry.comparingByKey()).

TreeSet maintains elements in sorted order automatically; adding elements by increasing order ensures O(log n) insertion complexity instead of potential collisions.

EnumSet is specialized for enums with bit-vector backing, providing better performance (O(1) operations) and memory efficiency than HashSet or TreeSet which use hashing/trees.

Use Collections.sort() for natural order, Collections.sort(list, comparator) for custom order, or list.stream().sorted().collect(Collectors.toList()).

Use Collections.synchronizedList(), Collections.synchronizedSet(), Collections.synchronizedMap() which return synchronized wrapper collections.

Use Collections.unmodifiableList(), Collections.unmodifiableSet(), Collections.unmodifiableMap() to get read-only collection views.

Use collection.toArray() for Object array or list.toArray(new Type[0]) for typed array in one call.

Use new ArrayList<>(hashset) or hashset.stream().collect(Collectors.toList()).

Use new HashSet<>(arraylist) or arraylist.stream().collect(Collectors.toSet()).

Collections.emptyList() returns an immutable singleton that's reused, while new copy creates a new instance; use emptyList() for efficiency.

HashMap doesn't guarantee O(1) complexity; it's average O(1) but can degrade to O(n) on hash collisions; Java 8+ uses trees for better worst-case.

There's no maximum number of hashCode() values; hashCode() returns int so theoretically 2^32 unique values, but multiple objects can hash to same value.

Main SET implementations: HashSet (hash-based), TreeSet (sorted/balanced tree), LinkedHashSet (insertion-order), EnumSet (bit-vector for enums).

Main MAP implementations: HashMap (hash-based), TreeMap (sorted/balanced tree), LinkedHashMap (insertion-order), Hashtable (legacy synchronized), ConcurrentHashMap (thread-safe).

CopyOnWriteArrayList/Set creates a copy of underlying array on modification, making reads fast but writes expensive; ideal for read-heavy concurrent scenarios.

Use cycling iteration: map.put(key1, value2); map.put(key2, value1); then iterate,each gets points to other's value creating a cycle.

MAP is not a Collection because it models key-value pairs, not a sequence of elements; Collection is for single-element values, incompatible with MAP's contract.

byte[] is unsuitable as HashMap key because arrays use reference-based equality/hashCode, not content-based; two arrays with same content have different hashes and aren't equal.

TreeSet uses a Red-Black tree for implementation, which maintains sorted order and provides O(log n) operations for add, remove, and search.