Home / Language / Record patterns (destructuring)
Language intermediate

Record patterns (destructuring)

Destructure records directly in patterns — extract fields in one step.

Code Comparison
✕ Java 8 
if (obj instanceof Point) {
    Point p = (Point) obj;
    int x = p.getX();
    int y = p.getY();
    System.out.println(x + y);
}
✓ Java 21+ 
if (obj instanceof Point(int x, int y)) {
    System.out.println(x + y);
}
Why the modern way wins
🎯

Direct extraction

Access record components without calling accessors manually.

🪆

Nestable

Patterns can nest — match inner records in a single expression.

📏

Compact code

Five lines become two — less ceremony, same clarity.

Old Approach
Manual Access
Modern Approach
Destructuring
Since JDK
21
Difficulty
intermediate
JDK Support
Record patterns (destructuring)
Available

Widely available since JDK 21 LTS (Sept 2023)

How it works

Record patterns let you decompose a record's components directly in instanceof and switch. Nested patterns are supported too, enabling deep matching without intermediate variables.

Related patterns

Language beginner

Diamond operator

Java 7
Map<String, List<String>> map =
    new HashMap<String, List<String>>();
// anonymous class: no diamond
Predicate<String> p =
    new Predicate<String>() {
        public boolean test(String s) {..}
    };
Java 9+
Map<String, List<String>> map =
    new HashMap<>();
// Java 9: diamond with anonymous classes
Predicate<String> p =
    new Predicate<>() {
        public boolean test(String s) {..}
    };
Hover to see modern ➜
JDK 9+ →
Language beginner

Records for data classes

Java 8
public class Point {
    private final int x, y;
    public Point(int x, int y) { ... }
    public int getX() { return x; }
    public int getY() { return y; }
    // equals, hashCode, toString
}
Java 16+
public record Point(int x, int y) {}
Hover to see modern ➜
JDK 16+ →
Language beginner

Unnamed variables with _

Java 8
try {
    parse(input);
} catch (Exception ignored) {
    log("parse failed");
}
map.forEach((key, value) -> {
    process(value); // key unused
});
Java 22+
try {
    parse(input);
} catch (Exception _) {
    log("parse failed");
}
map.forEach((_, value) -> {
    process(value);
});
Hover to see modern ➜
JDK 22+ →
Share 𝕏 🦋 in ⬡