Tag: java

Reservoir Sampling:One Pass When You Do Not Know n Up Front

Keep the first k items, then for each later index i (1-based), replace a slot with probability k/i — a uniform sample of k from a stream of unknown length.

Algorithms

Binary Exponentiation:pow(base, exp) in Logarithmic Multiplies

Square the base and consume the exponent bit by bit — O(log exp) multiplies instead of a loop of exp products, for integers or modular pow.

Algorithms

Fisher-Yates:Shuffle in Place Without Bias

For i from n-1 down to 1, swap a[i] with a uniform index in 0..i — every permutation equally likely, which is what Collections.shuffle already runs.

Algorithms

Euclid GCD:Subtract, Then Mod, Then Extended Coefficients

Replace repeated subtraction with remainder, then back-substitute for Bézout coefficients — gcd, lcm, and a modular inverse when gcd is 1.

Algorithms

Count-Min Sketch:Approximate Frequencies When Exact Maps Do Not Fit

d × w counters and the min over hashes: over-estimate frequencies on purpose when a HashMap of every key will not fit.

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.

Algorithms

Aho-Corasick:Many Patterns, One Pass Over the Text

Build a trie of all needles, add failure links like KMP on a forest, then scan the haystack once — every pattern that ends at the current character reports.

Algorithms

HyperLogLog:Approximate Distinct Count in Tiny Memory

Estimate cardinality with a handful of registers and a harmonic mean — plus-or-minus is the point, not a HashSet of every key.

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.

Algorithms

Boyer-Moore:Skip Ahead When the Mismatch Is Near the End

Align the pattern at the window end, use a bad-character skip (and the good-suffix idea) so a late mismatch jumps the haystack instead of sliding by one.

Design Patterns

Interpreter:Represent a Grammar and Evaluate It

Model a tiny promo DSL as AND/OR of percent-off and sku-in-category expressions that evaluate(Order), and skip it when a few ifs or a real parser would be honest.

Algorithms

Raft:Elect a Leader and Replicate a Log (Awareness, Not a From-Scratch Cluster)

Raft terms, leader election, and log replication at awareness depth — enough to know what etcd and Kafka-adjacent consensus are doing, not enough to ship your own cluster.

Design Patterns

Visitor:Add Operations Without Changing the Elements

Add CSV export and tax walks to a stable Sku / Category tree with accept(Visitor) so each new report is a class, not another method on every catalog type.

Algorithms

Rabin-Karp:Rolling Hash When You Need Many Pattern Checks

Slide a window hash in O(1), compare hashes first, then verify characters — the procedure for one needle or many needles against the same haystack.

Design Patterns

Prototype:Copy an Object Instead of Reconstructing It

Clone a configured DiscountPolicy, ChargeRequest, or gateway test double in Java instead of rebuilding constructor arguments — and skip clone() when new is cheaper or the copy shares mutable guts.

Algorithms

Two-Phase Commit:All Prepare, Then All Commit — and Why It Blocks

A coordinator asks every participant to prepare, then commit or abort together — and why a crashed coordinator leaves the cluster stuck.

Design Patterns

Memento:Snapshot State Without Breaking Encapsulation

Undo a checkout draft in Java by letting Order take an opaque snapshot — no public fields, no JSON dump, and no serializing OrderProcessor.

Design Patterns

Mediator:Keep Colleagues from Talking to Each Other

Stop DiscountPolicy, PaymentGateway, fraud, inventory, and the notifier from importing each other by letting CheckoutMediator own the checkout conversation.

Algorithms

Exponential Backoff:Retry With Jitter Instead of a Thundering Herd

Wait base × 2^attempt after a failure, cap the wait, and add jitter so retries do not stampede the same instant.

Design Patterns

Flyweight:Share What Does Not Change

Share immutable catalog SKU metadata across cart LineItems so a Black Friday order does not clone name, tax class, and image URL on every row.

Algorithms

Leaky Bucket:Smooth Bursts Into a Steady Drain

Queue work into a bucket that leaks at a constant rate — overflow is dropped or the caller waits. Smooth output, not a stored burst of tokens.

Design Patterns

Bridge:Split Abstraction from Implementation

Stop the Email×SendGrid / SMS×Twilio subclass grid by letting OrderNotifier hold a MessageSender so channels and vendors vary independently.

Algorithms

KMP:Find a Pattern Without Sliding Back on the Text

Build the LPS prefix table, then scan the text once — on a mismatch the pattern jumps using already-matched prefix, so the text index never retreats.

Design Patterns

Iterator:Walk a Collection Without Exposing Its Guts

Stop walking Order line items with get(i) on a leaked ArrayList so a switch from list to a SKU tree does not rewrite OrderProcessor.

Algorithms

Token Bucket:Allow Bursts, Then Enforce an Average Rate

Refill tokens at a steady rate, spend one per request, and allow a burst up to bucket capacity — then reject or wait.

Design Patterns

Abstract Factory:Families of Objects Without Naming the Concrete Types

Build Stripe-region and Razorpay-region checkout families in Java so gateway, webhook parser, and money type vary together without OrderProcessor naming the concretes.

Algorithms

Prim:Grow an MST From a Seed Vertex

Grow a min-heap of crossing edges from a seed until every vertex is in the tree — a Dijkstra-shaped frontier for an MST, not distances from a source.

Design Patterns

Chain of Responsibility:Pass a Request Until Someone Handles It

Replace a hard-coded fraud-inventory-payment-notify sequence with a Handler chain in Java so a new checkout step is a class you splice in, not a next-type you edit.

Algorithms

Consistent Hashing:Move Few Keys When a Node Joins or Dies

Place keys on a ring so adding or removing a node remaps only its neighbors — not every key — with virtual nodes to even the load.

Design Patterns

State:Change Behavior When Internal State Changes

Replace a growing DRAFT / PAID / REFUNDED / VOID switch in process, refund, and void with OrderStatus objects that own legal transitions, so OrderProcessor stops being the state machine.

Algorithms

Backtracking:Search With Undo When the Next Choice Depends on the Last

Choose, recurse, undo: search a decision tree with pruning when the next pick depends on the path — not a second knapsack table.

Design Patterns

Composite:Treat Trees of Objects as One

Replace nested loops over Outdoor / Hiking / SKUs with a CatalogNode tree so a category and a single product both answer subtotal(), and OrderProcessor still charges one payable.

Design Patterns

Proxy:Stand In for an Object You Cannot Touch Directly

Put a PaymentGateway proxy in front of a slow SDK so OrderProcessor still calls charge, while lazy init, an auth check, and a last-result cache decide whether the real gateway runs.

Algorithms

Interval Scheduling:Always Take the Finish That Frees the Room Soonest

Pick a maximum subset of non-overlapping intervals by earliest finish time — greedy that throws ranges away, not merge-intervals.

Design Patterns

Command:Turn a Request into an Object

Turn charge, refund, and capture into Java objects you can queue, retry, undo, or audit — without wrapping a one-shot process() in ceremony.

Design Patterns

Facade:One Simple Front for a Messy Subsystem

Hide checkout’s discount, payment, fraud, and tax conversation behind one CheckoutFacade.place(Order) so controllers stop assembling the subsystem.

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.

Algorithms

LZ77 and DEFLATE:Sliding-Window Compression Behind zip and gzip

Find repeated phrases in a sliding window as length-distance pairs, then Huffman-code the tokens — that pairing is DEFLATE, not Huffman alone.

Design Patterns

Template Method:Freeze the Skeleton, Vary the Steps

Freeze a shared Java payment sequence so capture, refund, and void keep one skeleton and only the provider step (and hooks) vary.

Algorithms

Huffman Coding:Build a Prefix Code From Frequencies

Build a prefix-free code from symbol frequencies with a heap: greedy merges, why it is optimal here, and why this is not DEFLATE.

Design Patterns

Singleton:One Instance, Used Carefully

Keep a process-wide resource as an enum singleton only when you can name why there must be one, and inject Clock, config, and gateways into OrderProcessor instead of AppContext.getInstance().

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.

Algorithms

Edit Distance:Insert, Delete, Substitute as a Costed Grid

Levenshtein distance on a DP grid: insert, delete, substitute, and recover one alignment — related to LCS, a different job.

Design Patterns

Builder:Assemble Complex Objects Step by Step

Replace a telescoping ChargeRequest constructor with a Java builder so required checkout fields stay required, optional ones stay optional, and the product can still be a record.

Design Patterns

Adapter:Make Incompatible Types Talk

Wrap a vendor client whose methods do not match PaymentGateway so OrderProcessor keeps calling charge(Order, BigDecimal) and never learns PayPal’s shape.

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.

Spring Boot

Spring Cache:Stop Querying for the Same Order Twice

Cache order reads with Spring @Cacheable and in-process Caffeine, evict on update, and keep JPA entities out of the cache.

Spring Boot

Flyway Without the `ddl-auto` Roulette

Version the orders schema with Flyway SQL migrations, turn off Hibernate ddl-auto outside local experiments, and prove the script with Testcontainers.

Spring Boot

When `@Valid` Fails, the Body Should Help:Problem Details and `@ControllerAdvice`

Turn Bean Validation failures and domain exceptions into RFC 7807 ProblemDetail responses with @ControllerAdvice so API clients get a body they can actually use.

Spring Boot

Profiles and Secrets:Stop Baking Production Into the Jar

Split Spring Boot config by profile, bind settings to a @ConfigurationProperties record, and inject secrets from the environment instead of committing them in the jar.

Spring Boot

RestClient After RestTemplate:One Client, Bounded Waits, Errors You Handle

Replace ad-hoc HTTP calls with Spring Boot 3 RestClient: inject the managed Builder, set timeouts, map JSON to records, and handle status codes without RestTemplate ceremony.

Algorithms

LIS:Longest Increasing Subsequence in n log n

Longest increasing subsequence: the O(n²) best-ending-here table, then patience / tails plus binary search for n log n.

Design Patterns

Decorator:Add Behavior Without Subclassing the Core

Replace AuditedRetryingCachedGateway subclasses with PaymentGateway wrappers you compose at the edge — logging, retry, cache — without a new type per combination.

Algorithms

LCS:Longest Shared Subsequence Without Requiring Contiguous

Find the longest common subsequence of two strings with a DP grid: match or skip, then reconstruct one shared sequence.

Design Patterns

Observer:Notify Dependents When Something Changes

Stop editing OrderProcessor for every new notification channel by publishing a payment event and letting EmailNotifier and AuditLog subscribe.

Design Patterns

Factory Method:Let Subclasses Decide Which Object to Build

Move construction of DiscountPolicy and PaymentGateway behind a polymorphic creator so six controllers stop naming PercentOff and StripeGateway.

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.

Algorithms

Coin Change:Unbounded Combinations When the Item Can Repeat

Make change when each denomination may be used again: min-coins and count combinations, and why this is not 0/1 knapsack.

Design Patterns

Strategy Pattern:Swap Algorithms Without Editing Callers

Replace a growing discount if/else with a Strategy in Java so each new promotion is a class you add, not a branch you edit into OrderProcessor.

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.

Algorithms

0/1 Knapsack:Pick or Skip When Each Item Exists Once

Fill a capacity with pick-or-skip DP: each item once, a 2D table or a 1D roll, and how to reconstruct which items went in.

Design Patterns

Design Patterns Roadmap:Pick the Right Pattern for the Pain You Have

A map of creational, structural, and behavioral patterns — what pain each one solves, when to skip it, and links to every post in this series.

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.

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.

Algorithms

Kruskal:Grow an MST by Cheapest Edge That Does Not Cycle

Sort every undirected edge cheapest-first, skip endpoints already in the same Union-Find component, accept the rest until n-1 edges — an MST that is not a shortest path from a source.

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.

Algorithms

A-Star:Dijkstra Plus a Heuristic When You Can Estimate Remaining Cost

Order the heap by f = g + h, settle toward a goal when h never overestimates remaining cost, and skip stale pairs like Dijkstra — the same procedure with a heuristic that may guess low, never high.

Algorithms

Floyd-Warshall:All-Pairs When n Is Small Enough for n³

Fill a dense distance matrix by relaxing every triple (k, i, j) — all-pairs shortest paths when n³ is the bill you can pay, and a negative on the diagonal is a negative cycle.

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.

Algorithms

Bellman-Ford:Shortest Path When a Negative Edge Is Allowed

Relax every edge V-1 times, then one more pass for a negative cycle — single-source shortest path when a weight is allowed to be negative.

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.

Algorithms

Dijkstra:Shortest Path When Every Edge Weight Is Non-Negative

Grow a min-heap frontier by current distance, settle each vertex once, and lazy-repush instead of decrease-key — the weighted cousin of BFS when every edge weight is non-negative.

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.

Algorithms

Strongly Connected Components:Collapse a Directed Graph to a DAG

DFS to record finish order, transpose the digraph, DFS again in reverse finish order — each second-pass tree is a strongly connected component, and the condensation is a DAG.

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.

Spring Boot

Spring Boot Observability:Health, Metrics, and Correlation IDs

Build an observable Spring Boot service with Actuator health probes, Prometheus metrics, W3C trace context, request IDs, and production-safe endpoint security.

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.

Spring Boot

Testing Slices + Testcontainers:Fast Tests Without Booting the Whole App

Choose focused Spring Boot test slices and verify a Spring Data JPA repository against a real PostgreSQL database with Testcontainers.

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 /** */.

Spring Boot

Spring Security Basics at the Service

Turn a Spring Boot API into an OAuth2 resource server, validate JWTs locally, and authorize business actions with method security instead of trusting the edge alone.

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.

Spring Boot

REST API with Boot 3 + Records as DTOs

Design a Spring Boot 3 REST boundary with Java records, Bean Validation, Jackson, and explicit mapping to service-owned models.

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.

Spring Boot

Spring Data JPA Footguns:Entities vs Records, N+1, Transactions

Build a safe Spring Data JPA boundary with proxy-friendly entities, record DTOs, explicit fetch plans, and service-owned transactions.

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.

Spring Boot

Spring Boot Virtual Threads:Flip One Flag, Then Fix What Breaks

Enable spring.threads.virtual.enabled on Boot 3.2+, understand what Tomcat and the application task executor actually switch, and size Hikari, RestClient, and observability so the flag does not become a thundering herd.

Algorithms

Topological Sort:Order a DAG Before You Run the Work

Emit each vertex only after its predecessors — Kahn with indegree and a queue, or DFS reverse finish times — and treat leftover vertices as a cycle.

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.

SOLID

SOLID in Practice:Apply the Five Without the Ceremony

Walk one order/payment notification service through all five SOLID principles end to end — the seams that matter, the ones that do not, and when to stop applying the checklist.

SOLID

Dependency Inversion:Depend on Abstractions, Not on `new`

Apply Dependency Inversion in Java: move Stripe and SMTP construction out of OrderProcessor, inject abstractions, and see how Spring DI is one wiring option — not the principle itself.

Spring Boot

Spring Cloud Gateway:Put a Front Door on Your Microservices

When to put an API gateway in front of your services, the trade-offs that matter, and a working Spring Cloud Gateway Server Web MVC example on the Servlet stack.

SOLID

Interface Segregation:Stop Forcing Clients to Depend on What They Ignore

Apply Interface Segregation in Java: break a fat PaymentOperations interface into client-shaped seams so charge, refund, and report clients stop stubbing unused methods.

Algorithms

Cycle Detection:Directed, Undirected, and the Color/Parent Trick

Detect a directed cycle with 3-color DFS (gray means on the recursion stack) and an undirected cycle by skipping the parent — a visited flag alone is the diamond trap.

SOLID

Liskov Substitution:Subtypes That Don't Surprise Callers

Spot Liskov Substitution violations in Java inheritance — UnsupportedOperationException, tightened preconditions, null surprises — and replace dishonest subtypes with honest types.

Algorithms

DFS:Finish Times, Recursion vs an Explicit Stack, and What a Cycle Looks Like

Walk a graph with DFS, stamp finish times, run the same walk on an ArrayDeque, and recognize a back edge as the shape of a cycle.

SOLID

Open-Closed:Add Behavior Without Rewriting the Core

Apply the Open-Closed Principle in Java: replace growing if/switch payment forests with extension seams so new providers are added, not edited into the core.

SOLID

Single Responsibility:One Reason to Change, Not One Method

What the Single Responsibility Principle actually means — one audience, one reason to change — with a Java OrderProcessor god class split into cohesive pieces.

SOLID

SOLID Roadmap:Five Principles Without the Textbook

What SOLID means in practice, a glossary of the five principles, when they become cargo-cult, and a map of this series — with a shared order/payment domain for later posts.

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.

Algorithms

BFS:Level Order, Shortest Unweighted Path, and Why the Frontier Is a Queue

Visit vertices in hop order with a FIFO queue — level order and unweighted shortest path — and see why a stack is the wrong frontier.

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.

Algorithms

External Sort:K-Way Merge When the File Does Not Fit in RAM

Sort RAM-sized chunks, write runs to disk, then k-way merge with a heap of heads — the in-memory merge-sort cousin when the file cannot be loaded.

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.

Algorithms

Timsort:What `Arrays.sort` Actually Runs on Objects

Natural runs, insertion on short runs, then merge — what object Arrays.sort and Collections.sort actually run, and why you should not hand-roll it.

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.

Algorithms

Radix Sort:Digit Passes When Comparison Is the Wrong Primitive

LSD digit passes as counting sort, when integer or string keys have a digit layout, and why Arrays.sort is not this.

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.

Algorithms

Counting Sort:Rank by Frequency When the Key Universe Is Small

Histogram, prefix of counts, and a stable place-from-the-right pass when keys come from a small universe.

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.

Algorithms

Heapsort:Sort With a Heap When You Need O(n log n) and Little Extra Memory

Build a max-heap and extract the max into the tail — guaranteed O(n log n), little extra memory, and why PriorityQueue poll-all is not this procedure.

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.

Algorithms

Quicksort:Partition in Place and Why the Pivot Policy Is the Algorithm

Partition around a pivot and recurse — and why last-element vs random vs median-of-three vs dual-pivot is the algorithm, not textbook Lomuto as Arrays.sort.

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.

Algorithms

Merge Sort:Stable Divide-and-Conquer When You Can Afford the Extra Array

Split, sort the halves, merge two sorted runs — why the extra array buys a guaranteed O(n log n) bound and stability, and what object Arrays.sort actually runs.

Algorithms

Quadratic Sorts:Insertion, Selection, and Why Bubble Survives Only in Interviews

Insertion still earns a seat on small or nearly-sorted ranges; selection swaps the min into place; bubble is a whiteboard name — none of them are the production default.

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.

Algorithms

Merge Intervals:Collapse Overlaps Instead of Sorting the Same Range Twice

Sort by start, sweep, and merge overlapping calendar or busy ranges — and when this is not interval scheduling.

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.

Algorithms

Kadane:Maximum Subarray Without Trying Every Slice

Running best ending here, empty-array and all-negative pitfalls, and why this is one pass of DP you do not need to name as a table.

Data Structures

Quadtrees and k-d Trees:Space as a Tree Instead of a Nested Loop

Spatial trees split the plane so range and nearest-neighbor queries skip whole regions. Quadtrees cut into four boxes; k-d trees alternate axis splits.

Algorithms

Prefix Sums:Answer a Range in O(1) After One Precompute

Inclusive vs exclusive prefixes, a 2D sketch, difference arrays for range updates, and when a Fenwick or segment tree is the next bill.

Algorithms

Sliding Window:Grow and Shrink a Range Without Restarting the Scan

Fixed and variable windows, the add-right / drop-left invariant, and why this is not the same thing as a rate-limit window.

Data Structures

Suffix Arrays:Substring Search Without a Full Suffix Tree

A suffix array is the sorted list of a string’s suffixes as start indices. Binary search finds substrings; a short section contrasts the heavier suffix tree.

Data Structures

Treaps:BST Order Plus Heap Priority

A treap is a BST on keys and a heap on random priorities. Rotations restore heap order so the shape stays balanced in expectation without color bits.

Algorithms

Two Pointers:One Pass From Both Ends Instead of a Nested Loop

Opposite-end, pair-sum on sorted data, and fast/slow — when two indexes replace O(n²) and when they are just two indexes.

Data Structures

Splay Trees:Move What You Touch to the Root

A splay tree is a BST that rotates the accessed node to the root. Recently used keys get cheap; amortized O(log n) without storing balance factors.

Algorithms

Binary Search:Cut the Space in Half When the Data Is Already Ordered

The sorted invariant, lower and upper bound, off-by-one, and what Arrays.binarySearch encodes when the key is missing.

Data Structures

LRU Cache:Hash Map Plus Doubly Linked List as One Machine

Least-recently-used eviction is O(1) only when a hash map points at nodes of a doubly linked list. How the two layouts share the work, and LinkedHashMap as the JDK shortcut.

Algorithms

Algorithms Roadmap:Pick the Procedure for the Job You Have

A map of search, sort, graphs, strings, DP, and systems algorithms — what job each one solves, when to skip it, and a living index of every post in this series.

Data Structures

Bloom Filters:Maybe-Yes, Definitely-No, and Why False Positives Are the Point

A Bloom filter is a bit array plus k hashes. It can say definitely not in the set, or maybe yes. False positives are the trade for tiny memory — never a false negative.

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.

Data Structures

Skip Lists:Layers of Express Lanes Instead of Rotations

A skip list is a layered linked list where higher levels skip ahead. Expected O(log n) search without tree rotations — Redis and ConcurrentSkipListMap use this idea.

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.

Data Structures

Fenwick Trees:Prefix Updates When a Segment Tree Is More Tree Than You Need

A Fenwick tree (BIT) stores prefix aggregates in an array using least-significant-bit jumps. Point update and prefix query in O(log n) with less machinery than a segment tree.

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.

Data Structures

Segment Trees:Range Queries Without Rescanning the Array

A segment tree stores aggregates of array ranges in a binary tree of intervals. Point update and range query in O(log n) without walking the whole slice each time.

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.

Data Structures

Union-Find:Connected Components Without Building a Graph

Disjoint sets with find and union: path compression and union by rank so “are these two in the same component?” stays nearly O(1) without storing an adjacency list.

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.

Data Structures

Tries:Prefix Search Without Scanning Every String

A trie stores strings by shared prefixes. Autocomplete and dictionary lookup become a walk down characters — not a scan of every word.

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.

Data Structures

Graphs:Adjacency List, Matrix, Directed and Weighted — Pick the Layout First

A graph is vertices and edges. Adjacency list vs matrix, directed vs undirected, weighted vs not — choose the representation before you think about an algorithm.

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.

Data Structures

Heaps:Priority in O(log n) Without Sorting the Whole Collection

A binary heap is a complete tree in an array that keeps the next-best element at the root. Min vs max, PriorityQueue in the JDK, and why you will hear Fibonacci heap without implementing one.

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.

Data Structures

B-Trees:Wide Nodes for Disk (and Why Databases Do Not Use BSTs)

A B-tree packs many keys per node so one disk page is one hop. Why databases and filesystems use this shape, and how B+ trees keep values in the leaves.

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.

Data Structures

Red-Black Trees:The Shape Behind `TreeMap` and `TreeSet`

A red-black tree is a BST painted with color rules that keep height logarithmic without AVL’s strict balance. Why TreeMap and TreeSet use this shape.

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.

Data Structures

AVL Trees:Height Balance When You Need Strict Guarantees

An AVL tree is a BST that rebalances on insert and delete so height stays O(log n). Balance factors, rotations, and when the extra strictness is worth it versus red-black.

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.

Data Structures

Binary Search Trees:Ordered Trees That Go Lopsided Under Sorted Input

A BST keeps left < node < right so search is O(height). Why already-sorted inserts become a linked list, and what that does to the bill.

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.

Data Structures

Binary Trees:Shape, Traversals, and What “Balanced” Even Means

A binary tree is a hierarchical layout: left, right, parent. Height vs size, preorder inorder postorder and level-order as operations of the shape, and what balanced actually promises.

Data Structures

Sets:Uniqueness Without Scanning the List

The set ADT is unique membership. HashSet delivers it with a hash table; List.contains is a scan. When TreeSet belongs instead, and what you lose (order).

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

Hash Tables:Buckets, Collisions, and When `HashMap` Lies About O(1)

How hashing maps a key to a bucket, what chaining and open addressing do with collisions, and why HashMap is expected O(1) — not a law of physics.

Data Structures

Deque:Both Ends Without Two Structures

A double-ended queue lets you push and pop at both ends in O(1). How ArrayDeque delivers that in the JDK, and when a deque is a stack, a queue, or a sliding window.

Data Structures

Queue:FIFO, Circular Buffers, and Why a Naive Array Queue Rotates

FIFO as an ADT: enqueue, dequeue, and why a naive array queue slides or wastes space — and how a circular buffer (ring) fixes both.

Data Structures

Stack:Undo, Parse, and Call Frames Are the Same Shape

LIFO as an ADT: push, pop, peek, and why undo, brace matching, and the call stack are the same layout — implemented with ArrayDeque, not java.util.Stack.

Data Structures

Linked Lists:Singly, Doubly, and Circular Without Losing the Head

How node-and-pointer lists make splice cheap when you already hold the node, why get(i) walks, and how singly, doubly, and circular variants differ.

Data Structures

Dynamic Arrays:Amortized Growth Without Pretending Append Is Always O(1)

How ArrayList grows by doubling, why append is amortized O(1) not a guarantee on the next call, and when a fixed array is the honest choice.

Data Structures

Arrays:Why Index `i` Is Free and Insert in the Middle Is Not

How a contiguous array makes index i O(1), why insert and delete in the middle slide everything, and how a 2D matrix is still the same layout.

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.

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.

Java

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.