Java 21: When will you upgrade?

Finally, it's here, lets straight jump into the features:

Java 21 is a long-term support (LTS) release of the Java SE (Standard Edition) platform. It was released on September 19, 2023, and is supported for 8 years, with Oracle providing security updates for the first 6 years and bug fixes for the entire eight-year support period.

Java 21 includes a number of new features, including:

• Virtual threads: Virtual threads are a lightweight threading model that can improve performance and scalability for applications that need to handle a large number of concurrent tasks.
• Generational Z garbage collector: The generational Z garbage collector is a new garbage collector that is designed to be more efficient and scalable than previous garbage collectors.
• Key encapsulation mechanism (KEM) API: The KEM API provides a way to securely encapsulate symmetric keys using public cryptography.
• Previews of string templates and structured concurrency: Java 21 includes previews of two new features, string templates, and structured concurrency, which are scheduled to be released in future versions of Java.

Other new features in Java 21 include:

• API improvements for the Stream API, the Date and Time API, and the Security API.
• New performance improvements, such as a new JIT compiler and a new garbage collection algorithm.
• New diagnostic tools and bug fixes.

Java 21 is a significant release that includes a number of new features that can improve the performance, scalability, and security of Java applications. It is a good choice for developers who are looking for a stable and reliable platform for building their applications.

Virtual threads:

This example creates a virtual thread and prints a message from it. The main thread then waits for the virtual thread to finish before exiting.

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.VirtualThread;

public class VirtualThreadExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        VirtualThread virtualThread = VirtualThread.start(() -> {
            System.out.println("Hello from the virtual thread!");
        });

        Future<Void> future = virtualThread.join();
        future.get();
    }
}        

Generational Z garbage collector:

The generational Z garbage collector is not available as a preview feature, so there is no example of its usage yet. However, it is expected to be more efficient and scalable than previous garbage collectors, which can improve the performance of Java applications.

Key encapsulation mechanism (KEM) API:

This example shows how to use the KEM API to securely encapsulate a symmetric key using public cryptography. The encrypted key can then be transmitted to another party without revealing the original symmetric key.

import java.security.GeneralSecurityException;
import java.security.KeyEncapsulationMechanism;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.SecretKey;

public class KEMExample {

    public static void main(String[] args) throws GeneralSecurityException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);

        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        SecretKey secretKey = KeyEncapsulationMechanism.getInstance("ECIES").generateSecret(publicKey);

        // Encrypt the secret key using the public key.
        byte[] encryptedSecretKey = KeyEncapsulationMechanism.getInstance("ECIES").encrypt(publicKey, secretKey);

        // Decrypt the secret key using the private key.
        SecretKey decryptedSecretKey = KeyEncapsulationMechanism.getInstance("ECIES").decrypt(keyPair.getPrivate(), encryptedSecretKey);

        // The decrypted secret key should be the same as the original secret key.
        if (secretKey.equals(decryptedSecretKey)) {
            System.out.println("The secret key was successfully decrypted!");
        } else {
            System.out.println("The secret key decryption failed!");
        }
    }
}        

Previews of string templates and structured concurrency:

String templates and structured concurrency are not available as preview features yet, so there are no examples of their usage yet. However, string templates are expected to make it easier to format and manipulate strings in Java, and structured concurrency is expected to simplify concurrent programming in Java.

String templates

String templates are a new feature in Java 21 that allows developers to create strings with embedded expressions. This can make it easier to format and manipulate strings, especially when working with complex data structures.

String template = "Hello, ${name}!";        

The ${name} expression will be replaced with the value of the name variable when the template is evaluated.

To evaluate a string template, you can use the String.formatted() method. For example:

String name = "Linkedin";
String greeting = String.formatted(template, name);
System.out.println(greeting); // Prints "Hello, Linkedin!"        

String templates can also be used to create more complex strings, such as SQL queries or JSON documents. For example:

String sqlQuery = """
SELECT * FROM users
WHERE name = '${name}'
""";

String jsonDocument = """
{
  "name": "${name}",
  "age": ${age}
}
""";
        

String templates are a powerful new feature that can make it easier to work with strings in Java.

Structured concurrency

Structured concurrency is another new feature in Java 21 that is designed to simplify concurrent programming. It provides a new API for creating and managing groups of concurrent tasks.

One of the key benefits of structured concurrency is that it makes it easier to handle errors and cancellations. When a task in a structured concurrency group fails, the other tasks in the group are automatically cancelled. This can help to prevent cascading failures and improve the overall reliability of your application.

Here is a simple example of how to use structured concurrency:

import java.util.concurrent.StructuredExecutor;
import java.util.concurrent.StructuredExecutor.StructuredTask;

public class StructuredConcurrencyExample {

    public static void main(String[] args) {
        StructuredExecutor executor = StructuredExecutor.create();

        StructuredTask task1 = executor.submit(() -> {
            // Do some work.
        });

        StructuredTask task2 = executor.submit(() -> {
            // Do some other work.
        });

        // Wait for both tasks to finish.
        executor.awaitAll(task1, task2);

        // If either task failed, throw an exception.
        if (!task1.isSuccessful() || !task2.isSuccessful()) {
            throw new Exception("One of the tasks failed!");
        }

        // Otherwise, everything went well.
        System.out.println("All tasks completed successfully!");
    }
}
        

In this example, we create a structured executor and submit two tasks to it. We then wait for both tasks to finish before exiting. If either task fails, we throw an exception. Otherwise, everything went well and we printed a success message.

Structured concurrency is a powerful new feature that can make concurrent programming in Java easier and more reliable.

Sequenced Collections

Sequenced Collections is a new feature in Java 21 that allows developers to work with collections in a sequential manner. It provides a set of interfaces and methods that make it easier to access the first and last elements of a collection, and to get a reversed view of the collection.

Sequenced Collections is built on top of the existing Java collections framework. It introduces a new interface, SequencedCollection, which extends the Collection interface. The SequencedCollection interface provides the following methods:

• getFirst(): Returns the first element in the collection.
• getLast(): Returns the last element in the collection.
• reversed(): Returns a reversed view of the collection.

The SequencedCollection interface is implemented by a number of existing Java collection classes, including ArrayList, LinkedList, and HashSet. This means that you can use the Sequenced Collections features with any of these collection classes.

Here is an example of how to use the Sequenced Collections features:

import java.util.ArrayList;
import java.util.SequencedCollection;

public class SequencedCollectionExample {

    public static void main(String[] args) {
        // Create a sequenced collection.
        SequencedCollection<String> sequencedCollection = new ArrayList<>();

        // Add some elements to the collection.
        sequencedCollection.add("Elon Musk");
        sequencedCollection.add("Jeff B");
        sequencedCollection.add("Bill G");

        // Get the first and last elements in the collection.
        String firstElement = sequencedCollection.getFirst();
        String lastElement = sequencedCollection.getLast();

        // Print the first and last elements.
        System.out.println("The first element is: " + firstElement);
        System.out.println("The last element is: " + lastElement);

        // Get a reversed view of the collection.
        SequencedCollection<String> reversedCollection = sequencedCollection.reversed();

        // Print the elements in the reversed collection.
        for (String element : reversedCollection) {
            System.out.println(element);
        }
    }
}        

Record Patterns

Record Patterns, is a new feature in Java 21 that allows developers to deconstruct record values using pattern matching. This can make it easier to write more concise and expressive code, and to handle different cases in a more elegant way.

Here is an example of how to use record patterns:

record Point(int x, int y) {}

public void printPoint(Point point) {
    switch (point) {
        case Point(0, 0):
            System.out.println("The point is at the origin.");
            break;
        case Point(var x, 0):
            System.out.println("The point is on the x-axis.");
            break;
        case Point(0, var y):
            System.out.println("The point is on the y-axis.");
            break;
        default:
            System.out.println("The point is somewhere else.");
    }
}
        

This example uses record patterns to deconstruct the point argument and print a different message depending on the value of the x and y coordinates.

Record patterns can also be used to extract the values of record components. For example, the following code extracts the x and y coordinates of the point argument and assigns them to the x and y variables, respectively:

record Point(int x, int y) {}
public void printPointCoordinates(Point point) {
    Point(var x, var y) = point;

    System.out.println("x: " + x);
    System.out.println("y: " + y);
}        

Record patterns are a powerful new feature that can make it easier to write more concise and expressive code when working with records.

Benefits of Record Patterns

Record patterns offer a number of benefits, including:

• Conciseness: Record patterns can help to write more concise code by eliminating the need to declare temporary variables and to write explicit checks for null values.
• Expressiveness: Record patterns can make code more expressive by allowing developers to deconstruct record values and handle different cases in a more elegant way.
• Safety: Record patterns can help to improve the safety of code by reducing the risk of errors such as null pointer exceptions and type casts.

Conclusion

Record patterns are a valuable new feature in Java 21 that can make it easier to write more concise, expressive, and safe code when working with records.

Finally though, if you or your organization are still at Java 8 or some other version then this is the high time to upgrade to Java 21.

Credit goes to Open JDK