Java Collections API

It is a framework of interfaces and classes used to store, manage, and process groups of objects efficiently.

Collections are dynamic (resize automatically), provide rich operations, and support powerful data structures like maps, sets, queues, and lists.

`java.util`

A:

• `Collection` is an interface (root for List, Set, Queue).
• `Collections` is a utility class (sorting, searching, wrappers, etc.).

A:

• `Collection` stores individual elements.
• `Map` stores key-value pairs and is not a subtype of Collection.

A:

• List
• Set
• Queue
• Deque
• Map (separate hierarchy)

Ordered elements with index-based access; duplicates are allowed.

Unique elements; duplicates are not allowed.

Typically FIFO processing (first in, first out), useful for task processing.

Double-ended queue; supports insertion/removal at both ends (FIFO or LIFO).

Fast lookup by key; associates each key with a value.

A resizable array-backed List with fast random access and good general-purpose performance.

A doubly-linked list implementing List and Deque, useful for frequent insert/delete at ends.

A:

• Use ArrayList by default.
• Use LinkedList mainly for frequent deque-style operations at ends.

Usually no; it is legacy synchronized List, and modern alternatives are preferred.

A:

• ArrayList: fast O(1)
• LinkedList: slow O(n)

Unordered Set backed by hash table; fast average add/remove/contains O(1).

HashSet that preserves insertion order.

Sorted Set (natural order or custom comparator), operations typically O(log n).

A:

• HashSet for speed and uniqueness only.
• TreeSet when sorted order/range operations are needed.

A:

• HashSet/LinkedHashSet: one null allowed.
• TreeSet: usually null not allowed (depends on comparator, typically throws).

Unordered key-value store with fast average O(1) put/get/remove.

HashMap with predictable iteration order (insertion order by default).

Sorted map by keys, with O(log n) operations.

Legacy synchronized map; generally replaced by HashMap/ConcurrentHashMap.

Thread-safe high-performance map for concurrent environments.

One null key and multiple null values are allowed.

Typically no (natural ordering/comparator usually rejects null key).

Queue ordered by priority (natural/comparator), not insertion order.

No; highest/lowest priority element is served first depending on comparator.

Fast resizable deque; often better than Stack/LinkedList for stack-queue behavior.

Stack is legacy; Deque (ArrayDeque) is the modern preferred stack implementation.

A:

• get/set: O(1)
• add at end: amortized O(1)
• insert/remove middle: O(n)

A:

• add/remove at ends: O(1)
• get by index/search: O(n)

Average O(1), worst-case O(n) (rare, depends on hash distribution/collisions).

O(log n) for add/remove/contains/get.

Wrong structure choices can severely hurt latency and throughput at scale.

Hash-based collections depend on both; violation causes failed lookup/removal behavior.

Object may become “lost” in collection because bucket location no longer matches.

A:

• Comparable: natural ordering inside class.
• Comparator: external/custom ordering strategy.

In sorted collections, inconsistent comparator can cause logical duplicates or unexpected behavior.

A:

• for-each loop
• Iterator
• ListIterator (for lists)
• forEach with lambda
• stream()

Sequential traversal with safe removal via `iterator.remove()`.

Bidirectional traversal and element add/set operations during iteration.

Structural modification during fail-fast iteration outside iterator’s own methods.

A:

• sort
• reverse
• shuffle
• binarySearch
• min/max
• unmodifiable wrappers
• synchronized wrappers

Returns a read-only view wrapper; underlying list changes are still reflected.

`List.of` creates truly immutable collection instance (no nulls, no structural changes).

Fewer bugs, safer sharing, easier reasoning, better thread-safety characteristics.

Creating a new collection copy to protect internal state from external mutation.

Return `List.copyOf(internalList)` instead of exposing mutable internal list directly.

No, not for concurrent writes without external synchronization.

A:

• synchronizedList: lock-based, good for balanced read/write.
• CopyOnWriteArrayList: great for many reads/few writes.

When multiple threads read/write map concurrently and high throughput is needed.

It is legacy and often slower/less flexible than modern concurrent collections.

Use HashSet.

Use LinkedHashSet.

Use HashMap<T, Integer> with getOrDefault or merge.

LinkedHashMap (access-order mode) + eviction policy.

TreeMap/TreeSet or PriorityQueue depending on query pattern.

Collections store data; streams process data pipelines.

No; use whichever is clearer and maintainable for the team.

`stream.toList()` (modern) or `collect(Collectors.toList())`.

`Collectors.groupingBy(…)`.

`stream.distinct()` (uses equals/hashCode).

If key fields in equals/hashCode change, map behavior breaks.

Causes O(n) access and poor performance.

May cause lock contention; consider concurrent collections or design changes.

HashMap order is not guaranteed.

Can throw ConcurrentModificationException; use iterator/removeIf.

ArrayList.

HashMap.

HashSet.

TreeSet.

ConcurrentHashMap.

Because collisions can degrade performance depending on hash distribution.

One.

No.

Not fully sorted by iterator traversal; only head is guaranteed by priority rule.

Iterator detects unexpected structural modifications and fails quickly.