Skip to content
AITroveRead. Build. Understand.
Reading list

Java Collections

Java collections supply membership, ordering and traversal contracts whose ownership, costs and concurrency behavior differ by implementation.

Java collections supply membership, ordering and traversal contracts whose ownership, costs and concurrency behavior differ by implementation.

Choose the question first

Use a List for ordered values, a Set for membership, a Map for a key-to-value association, or a Deque for endpoint work. Map is part of the collections framework but is not a subtype of Collection.

Ordering is a contract

TreeMap orders keys. LinkedHashMap keeps encounter order. PriorityQueue orders removals but does not supply sorted iteration. Those guarantees answer different questions.

Common Mistakes

Do not choose LinkedList simply because the workload inserts elements: finding an insertion position can dominate the edit. Count traversal, copying, allocation, and synchronisation needs before selecting an implementation.

Working through this section

The curriculum below groups the canonical pages for this section. Open a lesson to see its release label, operation contract and connected topics. Examples can also be linked from another section without creating a second copy of the same page.

Compile the stated program with a compatible JDK and compare its result with the displayed output. Read the rejected-input and ownership clauses before changing the input. Local self-checks and downloaded programs do not imply a server-side code judge or a production service.

Curriculum

Choose the operation family and keep mutation within a defined traversal policy.

  1. 1List, set or map?
  2. 2Java Iterator and ListIterator: traversal and controlled edits

Compare indexed access with linked traversal and endpoint operations.

  1. 1Java ArrayList and indexed access
  2. 2Java LinkedList: operations, internals and failure cases
  3. 3Java ArrayDeque for queues and stacks

Store mappings or unique values under a stable equality contract.

  1. 1Java HashMap: keys, collisions, and update operations
  2. 2Java HashSet: deduplication and equality

Use key order, encounter order, or removal priority intentionally.

  1. 1Java TreeMap: ordered keys and range views
  2. 2Java LinkedHashMap: encounter order and a bounded cache model
  3. 3Java PriorityQueue: ordered removal without a sorted list

Choose ordering, finite-domain keys, live views and snapshots.

  1. 1Java LinkedHashSet and TreeSet: order and uniqueness
  2. 2Java EnumMap and EnumSet: finite-state storage
  3. 3Java collection views: live wrappers, snapshots and shallow copies

Separate per-key updates from snapshots and bounded task admission.

  1. 1Java ConcurrentHashMap: atomic updates and weakly consistent reads
  2. 2Java blocking queues: bounded capacity and backpressure

Separate ordering, retained references and write costs.

  1. 1Java CopyOnWriteArrayList: listener snapshots and write amplification
  2. 2Java ConcurrentSkipListMap: ordered concurrent lookups and live ranges
  3. 3Java weak references: reachability is not a cache eviction schedule
  4. 4Java collection factories: rejected updates and shallow element ownership
  5. 5Java 21 sequenced collections: endpoints and reversed views
  6. 6Java comparators: tie-breakers, overflow and sorted-key identity

Inspect the state boundary and run its checked fixture.

  1. 1Java LinkedList ListIterator: edit at a cursor without repeated searches

Follow the input contract, inspect failures and run the checked source.

  1. 1Java LinkedHashMap LRU cache: access order changes eviction
  2. 2Java NavigableMap ranges: distinguish a live window from a snapshot

Check the boundary and follow the related lessons.

  1. 1Java LinkedList null elements: an empty-head ambiguity
  2. 2Java Deque empty operations: choose return values or exceptions
  3. 3Java LinkedList clone: copied nodes, shared element objects
  4. 4Java LinkedList indexed loops: a hidden quadratic traversal
  5. 5Java LinkedList duplicate removal: first and last occurrence
  6. 6Java List.remove with Integer: index or value
  7. 7Java synchronizedList iteration: hold the wrapper lock

Read the contract, run the checked fixture and inspect the rejected path.

  1. 1Java LinkedList subList: a live window, not a snapshot
  2. 2Java LinkedList descendingIterator: inspect and remove from the tail
  3. 3Java LinkedList toArray(T[]): the null terminator boundary
  4. 4Java LinkedList sort: stable order needs temporary array work
  5. 5Java LinkedList binarySearch: comparisons are not the whole cost
  6. 6Java LinkedList fail-fast iterators: a bug signal, not safety

Run the checked example, then inspect its rejected path and cost boundary.

  1. 1Java LinkedList ListIterator: the add, set and remove state machine
  2. 2Java checkedList on LinkedList: runtime checks at a raw boundary
  3. 3Java LinkedList retainAll: duplicates survive membership filtering
  4. 4Java indexOfSubList on LinkedList: find the first and last sequence
  5. 5Java Map.merge: combine a value or remove its mapping
  6. 6Java computeIfAbsent: null means no new mapping
  7. 7Java PriorityQueue: define tie order in the comparator
  8. 8Java LinkedList removeIf: keep a predicate narrow and side-effect free

Run the checked fixture, then inspect its ownership and failure boundary.

  1. 1Java IdentityHashMap: reference identity is not value equality
  2. 2Java TreeSet comparator collisions: compare zero means one slot
  3. 3Java EnumMap: declaration order and nullable values
Storage details