Java 21 New Features Complete Guide with Examples

Java 21 is the latest version of the Java programming language, and it comes with several exciting new features that can help developers improve their coding skills and create more efficient applications. In this tutorial, we will explore the new features of Java 21, including examples and step-by-step guides on how to use them. If you’re interested in learning more about Java, check out our More Java Tutorials for a comprehensive overview of the language.

Prerequisites

Before we dive into the new features of Java 21, make sure you have a good understanding of the basics of Java programming. If you’re new to Java, it’s recommended that you start with some basic tutorials and practice coding exercises. You can also review our Java Algorithms tutorial to learn more about common algorithms used in Java.

Pattern Matching for switch Statements

One of the new features in Java 21 is the ability to use pattern matching for switch statements. This feature allows you to specify multiple patterns for a single case, making your code more concise and efficient. Here’s an example:

public class PatternMatching {
    public static void main(String[] args) {
        Object obj = "Hello";
        switch (obj) {
            case String s -> System.out.println("The object is a string: " + s);
            case Integer i -> System.out.println("The object is an integer: " + i);
            default -> System.out.println("The object is something else");
        }
    }
}

This code uses pattern matching to specify two patterns for the switch statement: one for strings and one for integers. The code then prints out a message depending on the type of object.

Record Patterns

Another new feature in Java 21 is the ability to use record patterns. Record patterns allow you to specify a pattern for a record, which is a type of class that contains a fixed set of components. Here’s an example:

public record Person(String name, int age) {}

public class RecordPatterns {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        if (person instanceof Person(String name, int age)) {
            System.out.println("The person's name is " + name + " and their age is " + age);
        }
    }
}

This code uses a record pattern to specify a pattern for the Person record. The code then uses an if statement to check if the person object matches the pattern, and if so, prints out a message with the person’s name and age.

Common Mistakes

When using the new features of Java 21, there are some common mistakes to watch out for. One common mistake is to forget to specify the type of object when using pattern matching. For example:

public class PatternMatching {
    public static void main(String[] args) {
        Object obj = "Hello";
        switch (obj) {
            case String -> System.out.println("The object is a string");
            default -> System.out.println("The object is something else");
        }
    }
}

This code will not compile because the type of object is not specified. To fix this, you need to specify the type of object, like this:

public class PatternMatching {
    public static void main(String[] args) {
        Object obj = "Hello";
        switch (obj) {
            case String s -> System.out.println("The object is a string: " + s);
            default -> System.out.println("The object is something else");
        }
    }
}

Another common mistake is to forget to handle the default case when using pattern matching. For example:

public class PatternMatching {
    public static void main(String[] args) {
        Object obj = "Hello";
        switch (obj) {
            case String s -> System.out.println("The object is a string: " + s);
        }
    }
}

This code will not compile because the default case is not handled. To fix this, you need to add a default case, like this:

public class PatternMatching {
    public static void main(String[] args) {
        Object obj = "Hello";
        switch (obj) {
            case String s -> System.out.println("The object is a string: " + s);
            default -> System.out.println("The object is something else");
        }
    }
}

Conclusion

In conclusion, Java 21 comes with several exciting new features that can help developers improve their coding skills and create more efficient applications. By following this tutorial, you should now have a good understanding of the new features of Java 21, including pattern matching for switch statements and record patterns. For more information on Java and related topics, check out our SOLID Design Principles in Java tutorial or our Java Interview Questions section. You can also learn more about Mastering SQL to improve your database management skills.