Enables enhanced for-loop (for-each)

Basic operations: add, remove, size, contains, iterator

Ordered collection (preserves insertion order)

Allows duplicates

Index-based access (get/set by index)

No duplicates (based on equals/hashCode or comparator)

May or may not be ordered depending on implementation

Typically FIFO processing

Specialized for holding elements prior to processing

Double-ended queue (FIFO or LIFO)

Supports stack and queue operations

Key-value association

Unique keys, values can repeat

Resizable array

Fast random access: O(1) get/set

Amortized O(1) append (add at end)

Insert/remove in middle: O(n) due to shifting

Allows null elements

Not thread-safe

Frequent reads / index-based access

Append-heavy workloads

When size changes but mostly grows at end

Prefer initial capacity to reduce resizing

Doubly-linked list

Implements List and Deque

Access by index: O(n)

Insert/remove at ends: O(1)

Insert/remove in middle: O(1) once node found (finding is O(n))

Allows null

Not thread-safe

Frequent insertions/removals at head/tail

Queue/Deque usage (offer/poll/peek)

Usually worse cache locality than ArrayList

Synchronized (thread-safe via coarse locking)

Similar to ArrayList but slower under contention

Legacy codebases requiring Vector API

Prefer ArrayList + external synchronization or concurrent collections

Extends Vector; synchronized

LIFO operations: push/pop/peek

Legacy stack usage

Prefer Deque (ArrayDeque) for stack behavior

Copy-on-write array on mutation

Reads are lock-free and very fast

Writes are expensive (copy entire array)

Iterators are snapshot-based (no ConcurrentModificationException)

Allows null

Many readers, few writers

Listener lists, configuration snapshots

Not suitable for frequent updates or large lists

HashMap

No ordering guarantees

Average O(1) add/remove/contains

Allows one null element

Depends on correct hashCode/equals

Fast membership checks

De-duplication without ordering

Performance degrades with poor hashing or many collisions

LinkedHashMap

Preserves insertion order

Average O(1) operations

Allows one null

De-duplication while preserving insertion order

Stable iteration order for predictable output

TreeMap (Red-Black tree)

Sorted set (natural order or Comparator)

O(log n) add/remove/contains

Does not allow null (when using natural ordering; generally avoid null)

Need sorted unique elements

Range queries (subSet, headSet, tailSet)

Elements must be mutually comparable

Specialized for enum types

Very memory-efficient (bit vector)

Extremely fast operations

No nulls

Sets of enum flags (permissions, states)

Prefer over HashSet for enums

CopyOnWriteArrayList

Same trade-offs: fast reads, expensive writes

No duplicates, allows null depending on underlying list behavior (commonly avoid)

Many reads, few writes; small set of listeners

Resizable circular array

Very fast for stack/queue operations

O(1) amortized offer/poll/peek at both ends

No null elements allowed

Not thread-safe

Preferred stack replacement (push/pop)

High-performance FIFO queue in single-threaded contexts

Generally faster than LinkedList for Deque

Binary heap

Orders by priority (natural order or Comparator)

O(log n) offer/poll, O(1) peek

No null elements

Iteration order is not sorted

Not thread-safe

Scheduling, top-K, Dijkstra/A* frontiers

Anytime you need repeated “get smallest/largest”

Use reversed comparator for max-heap behavior

Lock-free, non-blocking FIFO

Weakly consistent iterators

No nulls

High-concurrency producer/consumer where blocking not needed

Lock-free deque

No nulls

Work-stealing queues, concurrent double-ended access

Producer-consumer with blocking put/take

Bounded, array-based

Optional fairness

Use Cases: fixed-capacity pipelines, backpressure

Optionally bounded, linked-node based

Typically higher throughput, more memory overhead

Use Cases: thread pools, task handoff

Unbounded, priority-ordered

Use Cases: prioritized task processing

Elements become available after delay (Delayed)

Use Cases: time-based scheduling, caches with expiry

No internal capacity; handoff directly between threads

Use Cases: direct handoff, cached thread pools

Supports transfer (producer waits for consumer if desired)

Use Cases: high-throughput messaging/handoffs

Bounded/unbounded blocking deque

Use Cases: task queues with both-end operations

Average O(1) get/put/remove

No ordering guarantees

Allows one null key, multiple null values

Not thread-safe

General-purpose key-value storage

Fast lookups by key

Requires stable hashCode/equals for keys

Good for caches if eviction not needed (otherwise consider LinkedHashMap)

Preserves insertion order or access order (configurable)

Slightly more overhead than HashMap

Allows null key/values

Predictable iteration order

LRU cache implementation (access-order + removeEldestEntry)

Sorted by key (natural or Comparator)

O(log n) operations

Does not allow null keys (generally)

Allows null values

Sorted key traversal

Range queries (subMap, headMap, tailMap)

Synchronized, coarse-grained locking

No null keys or values

Legacy compatibility only

Prefer ConcurrentHashMap for concurrency

Thread-safe with high concurrency (fine-grained/lock-striping-like behavior)

No null keys or values

Weakly consistent iterators

High-performance under contention

Shared maps in concurrent applications

Caches, counters, registries

Use computeIfAbsent/merge for atomic updates

Keys held with weak references

Entries removed when keys are no longer strongly reachable (GC-driven)

Allows null key/value

Caches where keys should not prevent GC

Metadata associations without memory leaks

Not predictable timing of removals

Compares keys by reference (==) not equals()

Allows null key/value

Object graph traversal, serialization frameworks

When identity semantics are required

Keys must be enum type

Very fast and memory-efficient (array-based)

No null keys; null values allowed

Replace Map<Enum, V> with best performance

Concurrent sorted map (skip list)

O(log n) operations

No null keys/values

Concurrent range queries and sorted traversal

Extends Hashtable; String-to-String commonly

Supports load/store of configuration

Configuration files (.properties)

ArrayList, LinkedList, HashMap, LinkedHashMap

ArrayDeque, PriorityQueue, ConcurrentHashMap, most concurrent queues

HashSet allows one null

TreeMap/TreeSet typically disallow null keys/elements with natural ordering

Truly immutable, disallow nulls

Constants, safe sharing, defensive copies