Java-21 on dplabs — Software Engineering & Technology Consultancy

Pattern Matching in Modern Java: Records, Switch, and Exhaustiveness

Mon, 20 Jan 2025 00:00:00 +0000

Pattern matching in Java 21 is the culmination of several interconnected features: instanceof patterns (Java 16), sealed classes (Java 17), switch expressions (Java 14), and switch patterns (Java 21). Understanding them individually is useful. Understanding how they compose is where the real power is.

The Baseline: Pattern Matching for instanceof

Before Java 16, checking and casting looked like this:

Object shape = getShape();
if (shape instanceof Circle) {
    Circle c = (Circle) shape;  // Redundant cast
    return c.area();
} else if (shape instanceof Rectangle) {
    Rectangle r = (Rectangle) shape;
    return r.area();
}

Java 16 introduced pattern variables in instanceof:

Java 17 to 21: Modern Java Is a Different Language

Mon, 16 Dec 2024 00:00:00 +0000

Java 21 is the current long-term support release as of late 2024, and it represents something unusual: a Java that looks substantively different from Java 8. Not just faster or more convenient — different in how you model domains and reason about concurrency.

This article focuses on the features that arrived between Java 17 and Java 21 (covered separately) and the cohesive picture they form together.

Pattern Matching for Switch (Finalized Java 21)

Pattern matching for instanceof arrived in Java 16. Java 21 extended pattern matching to switch — and this is where the power becomes apparent.

Virtual Threads in Java 21: What They Solve and What They Don't

Mon, 04 Nov 2024 00:00:00 +0000

Virtual threads were the most anticipated Java feature in years. Project Loom’s promise was simple: write blocking code that scales like non-blocking code. Java 21 delivered them as a finalized, production-ready feature. They work. The caveats matter.

The Problem Virtual Threads Solve

Traditional Java concurrency has a fundamental constraint: platform threads are expensive. Each platform thread maps 1:1 to an OS thread. OS threads consume roughly 1MB of stack space by default and are expensive to create and context-switch.