Pattern Matching for instanceof in Java

Introduction

Java, despite being a mature language, continues to evolve to embrace modern programming paradigms and best practices. Many of these enhancements focus on improving developer productivity and code readability.

One such feature was finally delivered in Java 16 and further improved in Java 17: JEP 394: Pattern Matching for instanceof.

This feature simplifies the writing of conditional logic involving type checks and casting, making the process more concise and expressive.

What is Pattern Matching?

Pattern matching is a programming construct that enables developers to test an object against a specific pattern. If the object matches the pattern, certain operations can be performed on it, such as extracting its properties or casting it to a specific type. This approach simplifies conditional logic by combining type checking, casting, and variable declaration into a single, concise operation.

Many programming languages, such as Scala, Kotlin, and Haskell, have implemented pattern matching as a core feature. With the introduction of JEP 394, Java has embraced this paradigm, offering developers a more modern and streamlined approach to type checking.

The problem with traditional instanceof

In traditional Java, checking an object's type requires two steps:

1. Using the instanceof operator to verify the type.
2. Explicitly casting the object to the desired type.

Here's an example:

public class TraditionalInstanceOf {
    public static void main(String[] args) {
        Object object = "Hello, World!";
        if (object instanceof String) {
            String string = (String) object; // Explicit cast is required
            System.out.println(string.toUpperCase());
        }
    }
}

While functional, this approach has a couple of drawbacks:

1. Repetition: The variable object is referenced multiple times: once in the instanceof check and again during the cast.
2. Verbosity: The explicit cast adds unnecessary boilerplate, reducing readability.

Pattern Matching for instanceof

JEP 394 eliminates the need for repetitive and redundant type checks by introducing a much cleaner and intuitive syntax. With this feature, you can combine type checking, casting, and variable declaration into a single operation.

Key advantages of pattern matching for instanceof include:

1. Reduced Boilerplate: There is no longer a need to write the type name multiple times, which makes your code more concise and direct.
2. Improved Readability: The code is easier to read and understand, as the type check and cast are combined into a single operation.
3. Safer Code: Since the type check and cast are merged, there is no chance of mismatched types or forgetting to update a cast if the code around it changes.

The following code snippet demonstrates how to use pattern matching for instanceof:

public class PatternMatchingInstanceOf {
    public static void main(String[] args) {
        Object object = "Hello, World!";
        if (object instanceof String string) {
            System.out.println(string.toUpperCase());
        }
    }
}

In this version, we can see the following improvements:

1. The instanceof operator not only checks the type but also declares and initializes a new variable (string) if the check passes.
2. The variable string is automatically cast to the appropriate type (String) within the scope of the if block.

Conclusion

Pattern Matching for instanceof represents a significant leap toward more expressive and concise Java code. By reducing boilerplate and clarifying how variables are scoped to their conditional blocks, it brings a clean, modern feel to everyday type checking. JEP 394 finalizes this feature in Java 16, demonstrating Java’s ongoing commitment to improving developer productivity with each release.

References

• JEP 394: Pattern Matching for instanceof
• JEP 375: Pattern Matching for instanceof (Second Preview)
• JEP 305: Pattern Matching for instanceof (Preview)