Tag: collections

Pick the Collection:Nulls, Order, Threads, and the Hot Operation

A decision guide for the Java Collections series: given the hot operation, null policy, encounter order, and whether another thread looks — which JDK type to new.

Java

Sequenced Collections:First, Last, and Reversed Without the Ceremony

Learn how Java 21 sequenced collections provide uniform first, last, and reversed operations across lists, deques, ordered sets, and ordered maps.

Java

Stream Gatherers:Custom Intermediate Ops Without Breaking the Pipeline

What Java Stream Gatherers are (JEP 485 / Java 24), why map/filter/flatMap hit a wall, built-ins like windowFixed and fold, and how to write a short custom gatherer.

Java

Java Streams:Filter, Map, and Collect Without the Nested Loop Soup

A beginner-to-intermediate guide to Java Streams: source → filter/map/flatMap → collect, lazy pipelines, and when a plain for loop is clearer.

Java

Spliterator and Collectors:Split a Collection and Put It Back Together

Use Collection.stream, parallelStream, spliterator characteristics, and Collectors.toCollection to leave a collection and land in the right one — without re-teaching Stream.map.

Java

Concurrent Queues and Skip Lists:Lock-Free Ends and Concurrent Order

Use ConcurrentLinkedQueue and ConcurrentLinkedDeque for non-blocking ends, and ConcurrentSkipListMap/Set when you need a concurrent sorted map — not a BlockingQueue and not a HashMap.

Java

BlockingQueue:Hand Off Work Without a Busy Wait

Use BlockingQueue to pass work between threads — put/take that block, offer/poll with timeouts, and when to pick Array, Linked, Delay, Synchronous, or Transfer queues.

Java

Copy-On-Write:Snapshot Iterators When Reads Dominate

Use CopyOnWriteArrayList and CopyOnWriteArraySet when iteration is the hot path — every mutation copies the array, and iterators walk a snapshot.

Java

ConcurrentHashMap:Shared Maps Without Synchronizing the Whole Table

Use ConcurrentHashMap for a shared map — per-bin concurrency, no nulls, weakly consistent iterators, and atomic compute/merge — not Hashtable and not synchronizedMap.

Java

Legacy Collections:Vector, Stack, Hashtable, and Why They Still Compile

Recognize Vector, Stack, Hashtable, Dictionary, Enumeration, and Properties as legacy — synchronized whole-table types you should not choose for new code.

Java

Collections and Arrays:Sort, Wrap, Copy, and the Methods You Forget

Use Collections and Arrays for sort, binarySearch, shuffle, nCopies, emptyXxx, synchronized wrappers, and asList — the static methods around the types, not a fourth List implementation.

Java

Collection Factories:`List.of` and `Map.copyOf` Without the Mutable Default

Use List.of, Set.of, Map.of, and copyOf for unmodifiable collections that reject nulls — Java 9 factories, not Collections.unmodifiableList wrapping a live ArrayList.

Java

IdentityHashMap and WeakHashMap:== Keys and GC-able Keys

Use IdentityHashMap when keys are compared with ==, and WeakHashMap when the GC should drop entries whose keys are otherwise unreachable — two unusual maps, two different jobs.

Java

EnumSet and EnumMap:Universe-Sized Keys Without a Hash

Use EnumSet and EnumMap when the key universe is an enum — a bit vector and an ordinal array, not a hash table.

Data Structures

Pick the Right Structure:Match the Job to the Data Layout

A decision guide for the data-structures series: given the hot operation, which layout and which JDK type — with links to every post in the series.

Java

Navigable Collections:TreeSet, TreeMap, and the Comparator Contract

Use TreeSet and TreeMap when keys must stay sorted — O(log n) red-black trees, Navigable ceiling/floor, and a Comparator that stays consistent with equals.

Java

PriorityQueue:Next-Best Without Sorting the Whole List

Use PriorityQueue when you need the next-best element in O(log n) — a heap, not a sorted list, and not a FIFO queue.

Java

LinkedHashMap:Insertion Order, Access Order, and a Real LRU

Use LinkedHashMap when a hash map must iterate in insertion order — or access order with removeEldestEntry for a bounded LRU.

Java

LinkedList:Nodes When ArrayList and ArrayDeque Already Lost

Use LinkedList only when you need List and Deque on the same nodes — and why it usually loses to ArrayList for indexes and ArrayDeque for ends.

Java

ArrayDeque:Stack and Queue Without Vector or LinkedList

Use ArrayDeque as the default deque — a resizable ring buffer for stack and queue work without Vector, Stack, or LinkedList.

Java

HashMap:The Default Map and What the Table Actually Does

Use HashMap as the default Map — hash spreading, buckets, treeify, resize, and why a mutable key makes an entry disappear.

Java

HashSet and LinkedHashSet:Unique Elements, With or Without Encounter Order

Use HashSet for uniqueness and LinkedHashSet when uniqueness still needs insertion order — both are HashMap wrappers, and neither is a sorted set.

Java

ArrayList:The Default List and When Growth Bites

Use ArrayList as the default List — amortized append, O(1) get, ensureCapacity, and the fail-fast iterator — and know when growth copies the whole array.

Java

Map:Keys, Values, and the Views That Stay in Sync

Use Map as mappings, not a Collection — get/put, compute and merge, and the keySet/values/entrySet views that write through to the same storage.

Java

Queue and Deque:Ends, Not Indexes

Use Queue and Deque when the job is the ends — offer/poll versus add/remove, exception versus special value, and why indexes are the wrong primitive.

Java

Set:Uniqueness Without Scanning the List

Use Set when uniqueness is the job — equals-based membership, no indexes, and why List.contains is the wrong uniqueness type.

Java

List:Index, SubList, and Random Access as a Type

Use List as an indexed contract — get/set, subList views, sort/replaceAll, and RandomAccess — without treating every List like an ArrayList.

Java

Collection and Iterator:The Contract Every List and Set Shares

Use Collection and Iterator as the shared contract — optional operations, fail-fast iteration, bulk methods, and removeIf — before you pick ArrayList or HashSet.

Java

Collections Roadmap:Pick the JDK Type for the Job You Have

The Java Collections Framework as a map: hierarchy, glossary, a nulls-order-threads matrix, and a living catalog of every post in this series.

Data Structures

Data Structures Roadmap:What to Learn from Arrays to Tries

A beginner-to-advanced path through data structures: glossary, Big-O literacy, a JDK map, and a living index of every post in this series.