Exploring the New Features in Java 23

Java 23, brings a host of new features and enhancements that every Java developer should be aware of. From flexible constructor bodies to structured concurrency, these updates aim to make Java more powerful and easier to use. In this article, we'll explore these new features and provide a comprehensive code example to demonstrate their usage.

Downloading the Early Access JDK 23

To get started with Java 23, you'll need to download the early access build. The early release build of JDK 23 can be found on the official OpenJDK website:

1. Visit the?JDK 23 Early Access page.
2. Select the appropriate build for your operating system (Windows, macOS, or Linux).
3. Download the archive file and extract it to a preferred directory.
4. Set your?JAVA_HOME?environment variable to point to the JDK 23 directory.
5. Update your system?PATH?to include the?bin?directory of the JDK 23 installation.

Once you have JDK 23 installed, you can start experimenting with the new features.

Primitive Patterns (JEP 455)

One of the most anticipated features in Java 23 is the introduction of primitive patterns. This feature allows you to use primitive types in patterns, making it easier to switch over or check the instance of a primitive value. This is a significant improvement, as it provides more options and flexibility when working with primitive types.

public class PrimitivePatterns {
    public static void main(String[] args) {
        Object obj = 42;
        if (obj instanceof Integer i) {
            System.out.println("Integer value: " + i);
        }
    }
}        

Flexible Constructor Bodies (JEP 482)

Java 23 introduces flexible constructor bodies, which allow assignments to fields in the same class. This feature simplifies the constructor logic and makes it more intuitive to initialize fields.

public class FlexibleConstructor {
    private int x;
    private int y;

    public FlexibleConstructor(int x) {
        this.x = x;
        {
            this.y = x * 2; // Allowed assignment to fields in the same class
        }
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}        

Simplified Main (JEP 477)

The simplified main feature allows you to write a Java source file that only contains a?void main?method without the need for a surrounding class. This makes the entry point of your application much cleaner and more straightforward.

// Simplified Java file
void main() {
    System.out.println("Hello, World!"); // Uses implicit import of print and println
}        

Module Imports (JEP 476)

Module imports in Java 23 make it easier to work with modules. You can now import all public types in all packages exported by a module with a single statement.

// Java file with module import
import module java.base;

public class ModuleImports {
    public static void main(String[] args) {
        System.out.println("Module Imports Example");
    }
}        

Structured Concurrency & Scoped Values (JEP 481 & 480)

Java 23 introduces structured concurrency and scoped values, which simplify writing and managing concurrent code. These features make concurrent programming more maintainable and easier to understand.

import java.util.concurrent.*;

public class StructuredConcurrency {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<String> future1 = scope.fork(() -> {
                return "Result 1";
            });
            Future<String> future2 = scope.fork(() -> {
                return "Result 2";
            });
            scope.join();
            scope.throwIfFailed();

            System.out.println("Structured Concurrency - " + future1.resultNow() + ", " + future2.resultNow());
        }
    }
}        

Class-File API (JEP 466)

The Class-File API allows for bytecode manipulation and analysis, providing a more robust way to handle class files programmatically.

import jdk.classfile.*;

public class ClassFileAPI {
    public static void main(String[] args) {
        ClassFile cf = ClassFile.read("MyClass.class");
        System.out.println(cf.toString());
    }
}        

Stream Gatherers (JEP 473)

Stream gatherers extend the capabilities of the Stream API, allowing for more flexible intermediate operations.

import java.util.stream.*;
import java.util.List;

public class StreamGatherers {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
        List<Integer> result = numbers.stream()
            .collect(Collectors.toList());
        System.out.println(result);
    }
}        

Vector API (JEP 469)

The Vector API in its eighth incubation provides a more efficient way to perform vector computations, leveraging the power of modern CPU architectures.

import jdk.incubator.vector.*;

public class VectorAPI {
    public static void main(String[] args) {
        VectorSpecies<Integer> SPECIES = IntVector.SPECIES_PREFERRED;
        IntVector a = IntVector.fromArray(SPECIES, new int[]{1, 2, 3, 4}, 0);
        IntVector b = IntVector.fromArray(SPECIES, new int[]{5, 6, 7, 8}, 0);
        IntVector c = a.add(b);
        int[] array = new int[4];
        c.intoArray(array, 0);
        System.out.println(c.toString());
    }
}        

Markdown in Comments (JEP 467)

Java 23 now supports Markdown in Javadoc comments, making it easier to write and read documentation. This feature enhances the readability of your code's documentation, providing better support for inline markup.

/**
 * ### Example of Markdown in Javadoc
 * - **Feature:** Markdown in Javadoc
 * - **Benefit:** Enhanced readability and ease of use
 */
public class MarkdownInComments {
    public static void main(String[] args) {
        System.out.println("Check the comments for Markdown examples!");
    }
}        

Conclusion

Java 23 introduces several powerful features that enhance the language's capabilities and simplify the development process. Whether it's the flexibility of constructor bodies, the simplification of the main method, or the advanced concurrency features, there's something for every developer to explore and utilize.

?