Java (72)

72 posts · 134tags

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.

Start here

Start here Series guide

Functional Interfaces Roadmap:The Four Shapes Behind Every Lambda

What a Java functional interface is, the four shapes in java.util.function, when to write your own SAM type, and a living map of every post in this series.

Start here

September 2026

Java

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

Primitive Types in Patterns:instanceof and switch Without the Wrapper Dance

Try JEP 532 in JDK 27: use primitive patterns with instanceof, switch directly on long, float, double, and boolean, and reject lossy conversions without hand-written casts.

Java

Lazy Constants:Initialize Once Without the Double-Checked Lock

Try JEP 531 in JDK 27: LazyConstant.of, List/Map/Set.ofLazy, and one-time thread-safe init the JIT can constant-fold — without double-checked locking.

Java

Your Key Vanished From the Map:`equals` and `hashCode` Without the Interview Checklist

Implement equals and hashCode so HashMap and HashSet can find the key you put — Object contract, records, and why a mutable id loses the entry.

Java

Exceptions:Checked, Unchecked, and When `throw` Beats `return`

Choose throw over a sentinel return, close resources with try-with-resources, and wrap checked exceptions at lambda boundaries instead of swallowing them.

Java

Generics:Write `List<Order>` Once and Mean It

Use Java generics so List of Order stays a list of orders — type parameters, PECS, erasure, and why raw types still compile.

Java

JUnit 5:Assert Behavior Before You Slice Spring

Prove an Order pricing rule with plain JUnit 5 — assertions, parameterized tests, and lifecycle — before you reach for a Spring test slice.

Java

`java.nio.file`:Paths, Copies, and Walks Without the Old IO Soup

Use Path and Files to read, copy, and walk directories in the JVM — without new File soup and without turning this into a Linux CLI tutorial.

Java

PEM Encodings:Keys and Certs Without the Internal Parser

What the Java 27 PEM API is (JEP 538): encode and decode keys, certificates, and CRLs with PEMEncoder and PEMDecoder — no BouncyCastle, no sun.security.util.

Java

AOT Caches:Faster Startup Without a Native Image

What Leyden AOT caches are (JEP 483, 514, 515, 516): train a HotSpot cache, then start faster and warm up sooner — still a JVM, not a GraalVM native image.

Java

Post-Quantum TLS:Hybrid Key Exchange Before the Quantum Deadline

What Java 27 JEP 527 is: hybrid ML-KEM + ECDHE named groups in TLS 1.3 so JSSE sessions survive store-now-decrypt-later — without writing crypto.

August 2026

Java

HTTP/3 for HttpClient:Speak HTTP/3 Without a Third-Party Stack

What Java 26 HttpClient HTTP/3 support is (JEP 517): opt in with Version.HTTP_3, fallback vs HTTP_3_URI_ONLY, and why the default stays HTTP/2.

Java

Final Means Final:Stop Mutating `final` Fields With Reflection

What JEP 500 does in Java 26: warn (not fail) when deep reflection mutates final fields, how to find the callers, and how to stop needing that hole.

Java

Key Derivation Functions:Derive Keys Without Rolling Your Own

What the Java 25 KDF API is (JEP 510): derive AES and HMAC keys with javax.crypto.KDF and HKDF-SHA256 instead of HMAC-then-truncate or a copied StackOverflow HKDF.

Java

Module Import Declarations:One `import module` Instead of a Wall of Stars

What Java 25 module import declarations are (JEP 511): import module M brings exported types into simple-name scope, how java.se and java.base fit, and how to resolve List clashes.

Java

Flexible Constructor Bodies:Validate Before `super()` Without the Hack

What flexible constructor bodies are (JEP 513 / Java 25): validate args and initialize fields in a constructor prologue before super() or this(), without the static-helper hack.

Java

Compact Source Files and Instance Main:`void main()` Without the Boilerplate

What compact source files are (JEP 512 / Java 25): implicit classes, instance main methods, java.lang.IO, and automatic java.base imports — without public static void main ceremony.

Java

Compact Object Headers:Cut Header Size Without Changing a Line of Code

What JEP 519 compact object headers are: shrink 64-bit HotSpot headers from 12–16 bytes to 8 without changing application source, how to enable the flag on 24/25, and why Java 27 turns it on by default.

Java

Class-File API:Parse and Transform Bytecode Without ASM

What the Java 24 Class-File API is (JEP 484): parse, generate, and transform .class files with java.lang.classfile so tools track the class-file format without a third-party ASM lag.

Java

Markdown Javadoc:Write Docs in `///` Instead of HTML Soup

What Java 23 Markdown documentation comments are (JEP 467): adjacent /// lines, CommonMark plus GFM tables, and how @param and {@link} still work beside /** */.

Java

Foreign Function and Memory API:Call Native Code Without the JNI Stack

What Java 22 FFM is (JEP 454): Arena, MemorySegment, and Linker downcalls so you can call native code and manage off-heap memory without JNI.

Java

Unnamed Variables and Patterns:Ignore What You Do Not Need With `_`

Learn where Java 22 lets you use underscore for intentionally unused locals, catch parameters, lambda parameters, type patterns, and nested record patterns.

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 Advanced:Collectors, Short-Circuiting, and Pitfalls That Bite in Production

Go beyond map/filter/collect: groupingBy, teeing, takeWhile/dropWhile, short-circuit order, primitive streams, parallel pitfalls, and Stream best practices for production Java.

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

Scoped Values:Share Immutable Context Without ThreadLocal Pain

What Java scoped values are (JEP 506 / Java 25), how they differ from ThreadLocal, why they fit virtual threads, and how to bind request context with where/run and where/call.

Java

Structured Concurrency:Treat Related Tasks as One Unit of Work

Learn the JDK 27 StructuredTaskScope factory API, Joiner policies, fan-in, sibling cancellation, and how structured concurrency fits virtual threads and scoped values.

Java

Sealed Classes + Pattern Switch:Exhaustive Code Without `instanceof` Soup

What sealed classes are (JEP 409 / Java 17), how pattern switch and record patterns finish the story on Java 21, and how to replace cascading instanceof with compiler-checked exhaustiveness.

Java

Locks After Loom:When `synchronized` Still Wins

After virtual threads, when intrinsic locks still win — pinning vs JEP 491, wait/notify, monitors, and ReentrantLock — so you do not treat synchronized as obsolete.

Java

Virtual Threads:Millions of Tasks Without a Thread Pool Circus

What Java virtual threads are (JEP 444 / Java 21), how they differ from platform threads, when they win for I/O-bound work, and the pinning and ThreadLocal gotchas—plus what Java 25 changed.

Java

Java Records:Immutable Data Without the Boilerplate

What Java records are, when they shipped (JEP 395 / Java 16), the problem they solve, and practical use cases with code—from DTOs to sealed-pattern matching.

July 2026

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.

June 2026

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.

May 2026

Java

Text Blocks:Multiline Strings Without the Concatenation Soup

Java 15 text blocks (JEP 378): triple-quote multiline strings, incidental indentation, and escape sequences — JSON, SQL, and HTML without + concatenation.

Java

Switch Expressions:Return a Value Without the Break Ritual

Java 14 switch expressions (JEP 361): arrow cases, yield, exhaustiveness — return a value without fall-through breaks. Pattern switch lives in a later post.

Java

HttpClient:Talk HTTP Without a Third-Party Stack

Use Java 11 java.net.http.HttpClient for HTTP/1.1 and HTTP/2 — builder, sync and async send, body handlers — without Apache HttpClient or OkHttp for ordinary calls.

Java

Local-Variable Type Inference:When `var` Clarifies and When It Hides

Java 10 var (JEP 286): use local-variable type inference when the right-hand side already names the type, and skip it when var hides what the reader needs.

Java

Java Modules:What `module-info.java` Actually Buys You

What JPMS (JEP 261) actually buys: explicit exports, requires, and a smaller runtime — not a file you copy into every repo. import module is a later language convenience.

Java

CompletableFuture:Compose Async Work Without Callback Hell

Compose async Java work with CompletableFuture — supplyAsync, thenApply, thenCompose, allOf — without nested callbacks, and when virtual threads are the simpler path.

Java

java.time:Dates Without Calendar and SimpleDateFormat

Replace Calendar and SimpleDateFormat with java.time — Instant, LocalDate, ZonedDateTime, formatting, and a Clock you can fake in tests.

Java

Optional:Return Absence Without Null and Without Wrapping Every Call

Use java.util.Optional to return absence without null — of/ofNullable, map/flatMap/filter, orElse vs orElseGet, and when wrapping every call is cargo-cult.

Java

Primitive Functional Interfaces:Skip the Box on the Hot Path

Use java.util.function’s primitive SAM grid to skip boxing on hot numeric paths, fill IntStream slots, and leave ToIntFunction out of ordinary application code.

Java

Bi-Arity:Two Arguments Without a Pair Type

Use BiFunction, BiPredicate, and BiConsumer for two-argument slots — apply, test, accept — and fill Map.merge, compute, and forEach without inventing a pair type.

Java

Unary and Binary Operators:Same Type In, Same Type Out

Use UnaryOperator and BinaryOperator when input and output are the same type — List.replaceAll, Stream.reduce, Collectors.reducing, and minBy / maxBy.

Java

Supplier:Produce a Value When Asked

Use Java’s Supplier<T> for lazy values — get, orElseGet, factories, supplyAsync — so you do not build work until something actually needs the result.

Java

Consumer:Accept a Value for a Side Effect

Use Java’s Consumer<T> for side effects — accept, andThen — and see where Stream.forEach, Optional.ifPresent, and peek already ask for it.

Java

Predicate:Ask a Yes/No Question You Can Combine

Use Java’s Predicate<T> to test values — test, and, or, negate, isEqual, Predicate.not (Java 11) — and see where Stream.filter, anyMatch, and removeIf already ask for it.

Java

Function:Turn T into R Without a One-Off Interface

Use Java’s Function<T,R> to map values — apply, compose, andThen, identity — and see where Stream.map, Optional.map, and Collectors already ask for it.