What is Pattern Matching in Java: Simple Explanation and Examples

In Java, pattern matching is a feature that simplifies checking an object's type and extracting its data in one step. It lets you write cleaner code by combining type checks and casts into a single concise expression.

How It Works

Pattern matching in Java works like a smart filter that checks if an object fits a certain shape or type, and if it does, it lets you use that object directly without extra steps. Imagine you have a box and you want to see if it contains a toy car. Instead of opening the box, checking the label, and then taking out the toy car, pattern matching lets you do all that in one quick move.

Before pattern matching, you had to check the type of an object with instanceof and then cast it to that type to use it. Pattern matching combines these two steps, so you write less code and avoid mistakes. It makes your programs easier to read and understand, especially when dealing with different types of objects.

Example

This example shows how pattern matching simplifies type checking and casting in Java.

java

public class PatternMatchingExample {
    public static void main(String[] args) {
        Object obj = "Hello, Java!";

        if (obj instanceof String s) {
            System.out.println("The string length is: " + s.length());
        } else {
            System.out.println("Not a string.");
        }
    }
}

Output

The string length is: 12

When to Use

Use pattern matching when you need to check an object's type and then work with it as that type. It is especially helpful in conditional statements like if or switch where you want to handle different types differently.

For example, in programs that process different shapes, messages, or data formats, pattern matching makes your code cleaner and less error-prone. It reduces the need for extra casting and helps avoid bugs caused by wrong type conversions.

Key Points

• Pattern matching combines type checking and casting in one step.
• It improves code readability and safety.
• Introduced in Java 16 for instanceof and expanded in later versions.
• Works well with if statements and switch expressions.

Key Takeaways

Pattern matching simplifies type checks and casts into one concise step.

It makes Java code easier to read and less error-prone.

Use it in conditional logic to handle different object types cleanly.

Introduced in Java 16 and improved in later versions for more use cases.