New Features in Java 23: A Comparison with Java 22

Java continues to evolve, and with each version, developers gain access to more powerful tools, enhanced performance, and improved syntax. In this article, we will explore the new features of Java 23 and compare them with its predecessor, Java 22.

1. What’s New in Java 23?

Java 23 introduces several exciting features that aim to improve the language and runtime environment.

1.1 Key Enhancements

Below are some of the key enhancements:

• Pattern Matching for Switch (Improved): This feature was introduced in Java 17 and received more refinements in Java 23. Java Developers can now write more readable and compact code by using pattern matching directly in switch statements for more complex types, including records and arrays. This enhancement reduces the need for excessive if-else logic. Here is a simple code example:

  sealed interface Shape permits Circle, Rectangle {}
  
  record Circle(double radius) implements Shape {}
  record Rectangle(double length, double width) implements Shape {}
  
  public class Main {
      public static void main(String[] args) {
          Shape shape = new Circle(5.0);
          
          String result = switch (shape) {
              case Circle c -> "Circle with radius: " + c.radius();
              case Rectangle r -> "Rectangle with length: " + r.length() + " and width: " + r.width();
          };
          
          System.out.println(result);
      }
  }
  

  Here, we use pattern matching in a switch statement to handle different shapes (circle, rectangle) and extract their attributes directly without casting or writing additional if-else blocks.
• Project Loom – Virtual Threads: Project Loom has been one of the most anticipated features. In Java 23, virtual threads are more stable and closer to production use. These lightweight threads are designed to handle massive concurrency, simplifying multithreading by reducing the resource overhead and complexity associated with traditional threads. Here is a simple code example:

  public class VirtualThreadExample {
      public static void main(String[] args) {
          try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
              IntStream.range(1, 10).forEach(i -> {
                  executor.submit(() -> {
                      System.out.println("Thread " + i + " is running");
                  });
              });
          }
      }
  }
  

  In this example, we create virtual threads using the new Executors.newVirtualThreadPerTaskExecutor() method. These threads are lightweight and designed for concurrent tasks.
• Record Patterns: Java introduced records to create immutable data classes with minimal boilerplate code. In Java 23, record patterns allow developers to destructure record types directly in pattern-matching expressions, making the syntax more concise and functional. Here is a simple code example:

  record Point(int x, int y) {}
  
  public class RecordPatternExample {
      public static void main(String[] args) {
          Object obj = new Point(3, 4);
          
          if (obj instanceof Point(int x, int y)) {
              System.out.println("Point with coordinates: " + x + ", " + y);
          }
      }
  }
  

  This code demonstrates how we can destructure a record type directly in an instanceof check, making the code more concise by automatically extracting the values of x and y from the Point object.
• Improved Garbage Collection (GC): Java 23 has made further improvements to its garbage collection algorithms, especially focusing on low-latency use cases. ZGC (Z Garbage Collector) and G1 (Garbage-First) collectors have seen performance tweaks, reducing application pauses, which is crucial for real-time and large-scale applications. Here is a simple code snippet:

  // Example flag usage for enabling ZGC
  // Run the JVM with the following option to enable ZGC:
  
  // java -XX:+UseZGC MyApp.java
  

  ZGC is designed for low-latency applications, and using this JVM flag enables the Z Garbage Collector. In large-scale or real-time applications, reducing pause times is critical, and ZGC provides better performance for these use cases.
• Sequenced Collections API: Java 23 introduces a new API to handle sequenced collections, such as lists, sets, and other ordered data structures. This API allows developers to handle common operations like reversing or processing data in sequential order more easily. Here is a simple code example:

  List numbers = List.of(1, 2, 3, 4, 5);
  var reversed = numbers.reversed();  // New method in Sequenced Collections API
  
  reversed.forEach(System.out::println);
  

  This code showcases the new reversed() method in the Sequenced Collections API, which reverses the order of elements in the list without the need for manually reversing them.
• Foreign Function and Memory API (Enhanced): The Foreign Function and Memory API, which allows Java programs to call native libraries and handle off-heap memory, is more robust in Java 23. The API has improved safety mechanisms, making it easier to write performant and safe code when working with non-Java memory. Here is a simple code example:

  import jdk.incubator.foreign.*;
  
  public class ForeignMemoryAccess {
      public static void main(String[] args) {
          try (MemorySegment segment = MemorySegment.allocateNative(1024)) {
              MemoryAddress address = segment.address();
              System.out.println("Allocated memory at address: " + address);
          }
      }
  }
  

  In this example, we use the Foreign Function and Memory API to allocate native memory (off-heap). The memory segment is automatically deallocated when it is no longer needed, thanks to the try-with-resources block.

2. Comparison Between Java 23 and Java 22

Feature	Java 22	Java 23
Pattern Matching for Switch	Introduced in earlier versions with limited support for certain types and less flexibility in handling more complex conditions like nested types.	Enhanced with better type handling, including arrays, records, and sealed classes. Developers can now write more concise and readable switch expressions, simplifying conditional logic and removing the need for excessive if-else constructs.
Project Loom – Virtual Threads	Provided experimental support for virtual threads, aimed at lightweight thread management, but was not stable for production environments. Focused on reducing the overhead of thread management in highly concurrent applications.	Virtual threads are more stable and closer to production readiness, offering improved performance and better scalability for multi-threaded applications. They allow for more efficient concurrent operations with minimal resource usage.
Record Patterns	Supported basic record types, but pattern matching with records was limited in scope. Could not fully destructure record types, requiring manual extraction of data members.	Expanded support for record patterns, enabling complete deconstruction within switch expressions and if statements. This simplifies working with immutable data, making pattern matching with records more powerful and expressive.
Garbage Collection (GC)	Continued improvements to ZGC and G1 collectors, providing low-latency options with better memory management. Some performance tweaks were introduced, but issues with long pause times persisted in certain use cases.	Further optimizations in ZGC and G1, focusing on reducing pause times and enhancing throughput for applications with real-time requirements. Java 23 provides better garbage collection performance for both small and large-scale applications.
Sequenced Collections	No specific API for handling sequenced collections in Java 22, requiring developers to manually implement reverse operations or sequential data processing in ordered collections.	Java 23 introduces the Sequenced Collections API, simplifying operations on ordered collections like lists and sets. It provides native methods for reversing collections, accessing elements in order, and performing sequential operations.
Foreign Function and Memory API	Provided as an incubator feature, enabling early use cases for native code interoperability and off-heap memory handling. However, it lacked comprehensive safety mechanisms and was experimental.	Java 23 enhances this API with improved safety features and better performance. The API allows for more stable and secure interactions with native libraries and off-heap memory, making it more suitable for production applications.

3. Conclusion

Java 23 is a significant upgrade over Java 22, especially for developers working with concurrent applications, performance-sensitive systems, or foreign libraries. The refinements in pattern matching, virtual threads, and garbage collection make it a powerful tool for modern Java development services. For developers already using Java 22, upgrading to Java 23 will offer performance boosts and more concise syntax, particularly with pattern matching and record handling. For more details, you can visit the official release pages for Java 22 and Java 23.