add/remove/contains/size/iterator

Ordered, index-based, allows duplicates

Sequence processing, random access, preserving insertion order

No duplicates

Uniqueness constraints, membership tests

Key-value pairs, unique keys

Lookup tables, caching, indexing by key

Typically FIFO; supports offer/poll/peek

Task scheduling, buffering, producer-consumer

Double-ended queue; stack/queue operations

Stack replacement, sliding windows, work-stealing patterns

Backed by dynamic array; fast random access; costly middle inserts/removes

Read-heavy lists, append-heavy workloads

Doubly linked; fast inserts/removes at ends/iterator position; slow random access

Also implements Deque

Frequent insert/remove, queue/deque use

Synchronized; generally slower than ArrayList

Legacy code requiring Vector API

Extends Vector; LIFO

Prefer ArrayDeque for stack-like behavior

Unordered; O(1) average add/contains; allows one null

Fast membership tests, deduplication without ordering needs

Preserves insertion order; slightly more overhead than HashSet

Deduplicate while preserving input order

Sorted set (natural order or Comparator); O(log n)

Need sorted unique elements, range queries (headSet/tailSet/subSet)

For enum types; very compact and fast (bit-vector)

Representing sets of flags/options

Unordered; O(1) average get/put; allows one null key and null values

General-purpose key-value store, fast lookups

Predictable iteration order (insertion or access order)

Can implement LRU-like caches (removeEldestEntry)

Ordered iteration, simple caching

Sorted by key; O(log n); supports range views (subMap, etc.)

Sorted dictionaries, range queries, ordered traversal

Synchronized; no null keys/values; largely superseded

Legacy compatibility; prefer ConcurrentHashMap or synchronizedMap

Thread-safe with high concurrency; no null keys/values

Shared maps in multi-threaded applications

Keys are enum; very efficient array-based

Mapping enum states to values

Keys held weakly; entries removed when key no longer referenced

Caches tied to object lifecycle, avoiding memory leaks

Key equality by reference (==) instead of equals()

Object graph processing, identity-based registries

Resizable circular array; fast for stack/queue; no nulls

Preferred stack (push/pop) or deque; BFS/DFS buffers

Heap; orders by priority (Comparator/natural); not FIFO

Scheduling, top-K, Dijkstra/A* style workloads

Lock-free thread-safe FIFO

High-throughput concurrent messaging/buffering

Blocking put/take for coordination

ArrayBlockingQueue

LinkedBlockingQueue

PriorityBlockingQueue

DelayQueue

SynchronousQueue

Producer-consumer pipelines, thread pools, rate-limiting patterns

LinkedHashMap/LinkedHashSet

TreeMap/TreeSet (Comparator)

HashMap/HashSet

Simple but can bottleneck

High-read concurrency, lock-free patterns

API safety, defensive programming