JDK New Features Summary

List of JDK New feature summary for each release.

JDK22

Unnamed Variables & Patterns

In https://openjdk.org/jeps/456.

• Unnamed variables

  Here are the examples to use unnamed variables.

  • An enhanced for loop with side effects:

    Java

    static int count(Iterable<Order> orders) {
        int total = 0;
        for (Order _ : orders)    // Unnamed variable
            total++;
        return total;
    }
    

    The initialization of a simple for loop can also declare unnamed local variables:

    Java

    for (int i = 0, _ = sideEffect(); i < 10; i++) { ... i ... }
    

  • An assignment statement, where the result of the expression on the right-hand side is not needed:

    Java

    Queue<Integer> q = ... // x1, y1, z1, x2, y2, z2, ...
    while (q.size() >= 3) {
    var x = q.remove();
    var y = q.remove();
    var _ = q.remove();        // Unnamed variable
    ... new Point(x, y) ...
    }
    

    If the program needed to process only the x1, x2, etc., coordinates then unnamed variables could be used in multiple assignment statements:
    Java

    while (q.size() >= 3) {
        var x = q.remove();
        var _ = q.remove();       // Unnamed variable
        var _ = q.remove();       // Unnamed variable
        ... new Point(x, 0) ...
    }
    

  • A catch block:

    Java

    String s = ...
    try {
        int i = Integer.parseInt(s);
        ... i ...
    } catch (NumberFormatException _) {        // Unnamed variable
        System.out.println("Bad number: " + s);
    }
    

    Unnamed variables can be used in multiple catch blocks:
    Java

    try { ... }
    catch (Exception _) { ... }                // Unnamed variable
    catch (Throwable _) { ... }                // Unnamed variable
    

  • In try-with-resources:

    Java

    try (var _ = ScopedContext.acquire()) {    // Unnamed variable
        ... no use of acquired resource ...
    }
    

  • A lambda whose parameter is irrelevant:

    Java

    ...stream.collect(Collectors.toMap(String::toUpperCase,
                                _ -> "NODATA"))    // Unnamed variable
    

Statements before super(...) (Preview)

In https://openjdk.org/jeps/447.

In constructors in the Java programming language, allow statements that do not reference the instance being created to appear before an explicit constructor invocation.

• Validating superclass constructor arguments

  Sometimes we need to validate an argument that is passed to a superclass constructor. We can validate the argument after the fact, but that means potentially doing unnecessary work:

  Java

  public class PositiveBigInteger extends BigInteger {
  
      public PositiveBigInteger(long value) {
          super(value);               // Potentially unnecessary work
          if (value <= 0)
              throw new IllegalArgumentException("non-positive value");
      }
  
  }
  

  It would be better to declare a constructor that fails fast, by validating its arguments before it invokes the superclass constructor. Today we can only do that in-line, using an auxiliary static method:

  Java

  public class PositiveBigInteger extends BigInteger {
  
      public PositiveBigInteger(long value) {
          super(verifyPositive(value));
      }
  
      private static long verifyPositive(long value) {
          if (value <= 0)
              throw new IllegalArgumentException("non-positive value");
          return value;
      }
  
  }
  

  This code would be more readable if we could include the validation logic directly in the constructor. What we would like to write is:

  Java

  public class PositiveBigInteger extends BigInteger {
  
      public PositiveBigInteger(long value) {
          if (value <= 0)
              throw new IllegalArgumentException("non-positive value");
          super(value);
      }
  
  }
  

• Preparing superclass constructor arguments

  Sometimes we must perform non-trivial computation in order to prepare arguments for a superclass constructor, resorting, yet again, to auxiliary methods:

  Java

  public class Sub extends Super {
  
      public Sub(Certificate certificate) {
          super(prepareByteArray(certificate));
      }
  
      // Auxiliary method
      private static byte[] prepareByteArray(Certificate certificate) { 
          var publicKey = certificate.getPublicKey();
          if (publicKey == null) 
              throw new IllegalArgumentException("null certificate");
          return switch (publicKey) {
              case RSAKey rsaKey -> ...
              case DSAPublicKey dsaKey -> ...
              ...
              default -> ...
          };
      }
  
  }
  

• Sharing superclass constructor arguments

  Sometimes we need to compute a value and share it between the arguments of a superclass constructor invocation. The requirement that the constructor invocation appear first means that the only way to achieve this sharing is via an intermediate auxiliary constructor:

  Java

  public class Super {
  
      public Super(F f1, F f2) {
          ...
      }
  
  }
  
  public class Sub extends Super {
  
      // Auxiliary constructor
      private Sub(int i, F f) { 
          super(f, f);                // f is shared here
          ... i ...
      }
  
      public Sub(int i) {
          this(i, new F());
      }
  
  }
  

  In the public Sub constructor we want to create a new instance of a class F and pass two references to that instance to the superclass constructor. We do that by declaring an auxiliary private constructor.

  The code that we would like to write does the copying directly in the constructor, obviating the need for an auxiliary constructor:

  Java

  public Sub(int i) {
          var f = new F();
          super(f, f);
          ... i ...
  }
  

• Pre-construction contexts

  • any unqualified this expression is disallowed in a pre-construction context

    Java

    class A {
    
        int i;
    
        A() {
            this.i++;                   // Error
            this.hashCode();            // Error
            System.out.print(this);     // Error
            super();
        }
    
    }
    

  • any field access, method invocation, or method reference qualified by super is disallowed in a pre-construction context

    Java

    class D {
        int i;
    }
    
    class E extends D {
    
        E() {
            super.i++;                  // Error
            super();
        }
    
    }
    

  • an illegal access does not need to contain a this or super keyword

    Java

    class A {
    
        int i;
    
        A() {
            i++;                        // Error
            hashCode();                 // Error
            super();
        }
    
    }
    

    More confusingly, sometimes an expression involving this does not refer to the current instance but, rather, to the enclosing instance of an inner class:

    Java

    class B {
    
        int b;
    
        class C {
    
            int c;
    
            C() {
                B.this.b++;             // Allowed - enclosing instance
                C.this.c++;             // Error - same instance
                super();
            }
    
        }
    
    }
    

    Unqualified method invocations are also complicated by the semantics of inner classes:

    Java

    class Outer {
    
        void hello() {
            System.out.println("Hello");
        }
    
        class Inner {
    
            Inner() {
                hello();                // Allowed - enclosing instance method
                super();
            }
    
        }
    
    }
    

    The invocation hello() that appears in the pre-construction context of the Inner constructor is allowed because it refers to the enclosing instance of Inner (which, in this case, has the type Outer), not the instance of Inner that is being constructed.

    In the previous example, the Outer enclosing instance was already constructed, and therefore accessible, whereas the Inner instance was under construction and therefore not accessible. The reverse situation is also possible:

    Java

    class Outer {
    
        class Inner {
        }
    
        Outer() {
            new Inner();                // Error - 'this' is enclosing instance
            super();
        }
    
    }
    

    The expression new Inner() is illegal because it requires providing the Inner constructor with an enclosing instance of Outer, but the instance of Outer that would be provided is still under construction and therefore inaccessible.

    Similarly, in a pre-construction context, class instance creation expressions that declare anonymous classes cannot have the newly created object as the implicit enclosing instance:

    Java

    class X {
    
        class S {
        }
    
        X() {
            var tmp = new S() { };      // Error
            super();
        }
    
    }
    

    Here the anonymous class being declared is a subclass of S, which is an inner class of X. This means that the anonymous class would also have an enclosing instance of X, and hence the class instance creation expression would have the newly created object as the implicit enclosing instance. Again, since this occurs in the pre-construction context it results in a compile-time error. If the class S were declared static, or if it were an interface instead of a class, then it would have no enclosing instance and there would be no compile-time error.

    This example, by contrast, is permitted:

    Java

    class O {
    
        class S {
        }
    
        class U {
    
            U() {
                var tmp = new S() { };  // Allowed
                super();
            }
    
        }
    
    }
    

  • Unlike in a static context, code in a pre-construction context may refer to the type of the instance under construction, as long as it does not access the instance itself

    Java

    class A<T> extends B {
    
        A() {
            super(this);                // Error - refers to 'this'
        }
    
        A(List<?> list) {
            super((T)list.get(0));      // Allowed - refers to 'T' but not 'this'
        }
    
    }
    

Stream Gatherers (Preview)

In https://openjdk.org/jeps/461.

Enhance the Stream API to support custom intermediate operations. This will allow stream pipelines to transform data in ways that are not easily achievable with the existing built-in intermediate operations.

Built-in gatherers,

• fold is a stateful many-to-one gatherer which constructs an aggregate incrementally and emits that aggregate when no more input elements exist.

• mapConcurrent is a stateful one-to-one gatherer which invokes a supplied function for each input element concurrently, up to a supplied limit.

• scan is a stateful one-to-one gatherer which applies a supplied function to the current state and the current element to produce the next element, which it passes downstream.

• windowFixed is a stateful many-to-many gatherer which groups input elements into lists of a supplied size, emitting the windows downstream when they are full.

• windowSliding is a stateful many-to-many gatherer which groups input elements into lists of a supplied size. After the first window, each subsequent window is created from a copy of its predecessor by dropping the first element and appending the next element from the input stream..

For example, Stream.of(1,2,3,4,5,6,7,8,9).gather(Gatherers.windowFixed(3)).toList().

String Templates (Second Preview)

In https://openjdk.org/jeps/459.

• The STR template processor

  Java

  // Embedded expressions can be strings
  String firstName = "Bill";
  String lastName  = "Duck";
  String fullName  = STR."\{firstName} \{lastName}";
  | "Bill Duck"
  String sortName  = STR."\{lastName}, \{firstName}";
  | "Duck, Bill"
  
  // Embedded expressions can perform arithmetic
  int x = 10, y = 20;
  String s = STR."\{x} + \{y} = \{x + y}";
  | "10 + 20 = 30"
  
  // Embedded expressions can invoke methods and access fields
  String s = STR."You have a \{getOfferType()} waiting for you!";
  | "You have a gift waiting for you!"
  String t = STR."Access at \{req.date} \{req.time} from \{req.ipAddress}";
  | "Access at 2022-03-25 15:34 from 8.8.8.8"
  

• Multi-line template expressions

  Java

  record Rectangle(String name, double width, double height) {
      double area() {
          return width * height;
      }
  }
  Rectangle[] zone = new Rectangle[] {
      new Rectangle("Alfa", 17.8, 31.4),
      new Rectangle("Bravo", 9.6, 12.4),
      new Rectangle("Charlie", 7.1, 11.23),
  };
  String table = STR."""
      Description  Width  Height  Area
      \{zone[0].name}  \{zone[0].width}  \{zone[0].height}     \{zone[0].area()}
      \{zone[1].name}  \{zone[1].width}  \{zone[1].height}     \{zone[1].area()}
      \{zone[2].name}  \{zone[2].width}  \{zone[2].height}     \{zone[2].area()}
      Total \{zone[0].area() + zone[1].area() + zone[2].area()}
      """;
  | """
  | Description  Width  Height  Area
  | Alfa  17.8  31.4     558.92
  | Bravo  9.6  12.4     119.03999999999999
  | Charlie  7.1  11.23     79.733
  | Total 757.693
  | """
  

• The FMT template processor

  Java

  record Rectangle(String name, double width, double height) {
      double area() {
          return width * height;
      }
  }
  Rectangle[] zone = new Rectangle[] {
      new Rectangle("Alfa", 17.8, 31.4),
      new Rectangle("Bravo", 9.6, 12.4),
      new Rectangle("Charlie", 7.1, 11.23),
  };
  String table = FMT."""
      Description     Width    Height     Area
      %-12s\{zone[0].name}  %7.2f\{zone[0].width}  %7.2f\{zone[0].height}     %7.2f\{zone[0].area()}
      %-12s\{zone[1].name}  %7.2f\{zone[1].width}  %7.2f\{zone[1].height}     %7.2f\{zone[1].area()}
      %-12s\{zone[2].name}  %7.2f\{zone[2].width}  %7.2f\{zone[2].height}     %7.2f\{zone[2].area()}
      \{" ".repeat(28)} Total %7.2f\{zone[0].area() + zone[1].area() + zone[2].area()}
      """;
  | """
  | Description     Width    Height     Area
  | Alfa            17.80    31.40      558.92
  | Bravo            9.60    12.40      119.04
  | Charlie          7.10    11.23       79.73
  |                              Total  757.69
  | """
  

Implicitly Declared Classes and Instance Main Methods (Second Preview)

In https://openjdk.org/jeps/463.

Allow to write a Java main like,

class HelloWorld {
    void main() {
        System.out.println("Hello, World!");
    }
}

// or

void main() {
    System.out.println("Hello, World!");
}

Foreign Function & Memory API

In https://openjdk.org/jeps/454.

Introduce an API by which Java programs can interoperate with code and data outside of the Java runtime. By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI.

The Foreign Function & Memory API (FFM API) defines classes and interfaces so that client code in libraries and applications can

• Control the allocation and deallocation of foreign memory(MemorySegment, Arena, and SegmentAllocator),
• Manipulate and access structured foreign memory(MemoryLayout and VarHandle), and
• Call foreign functions (Linker, SymbolLookup, FunctionDescriptor, and MethodHandle).

The FFM API resides in the java.lang.foreign package of the java.base module.

As a brief example of using the FFM API, here is Java code that obtains a method handle for a C library function radixsort and then uses it to sort four strings which start life in a Java array (a few details are elided).

// 1. Find foreign function on the C library path
Linker linker          = Linker.nativeLinker();
SymbolLookup stdlib    = linker.defaultLookup();
MethodHandle radixsort = linker.downcallHandle(stdlib.find("radixsort"), ...);
// 2. Allocate on-heap memory to store four strings
String[] javaStrings = { "mouse", "cat", "dog", "car" };
// 3. Use try-with-resources to manage the lifetime of off-heap memory
try (Arena offHeap = Arena.ofConfined()) {
    // 4. Allocate a region of off-heap memory to store four pointers
    MemorySegment pointers
        = offHeap.allocate(ValueLayout.ADDRESS, javaStrings.length);
    // 5. Copy the strings from on-heap to off-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = offHeap.allocateFrom(javaStrings[i]);
        pointers.setAtIndex(ValueLayout.ADDRESS, i, cString);
    }
    // 6. Sort the off-heap data by calling the foreign function
    radixsort.invoke(pointers, javaStrings.length, MemorySegment.NULL, '\0');
    // 7. Copy the (reordered) strings from off-heap to on-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = pointers.getAtIndex(ValueLayout.ADDRESS, i);
        javaStrings[i] = cString.reinterpret(...).getString(0);
    }
} // 8. All off-heap memory is deallocated here
assert Arrays.equals(javaStrings,
                     new String[] {"car", "cat", "dog", "mouse"});  // true

This code is far clearer than any solution that uses JNI, since the implicit conversions and memory accesses that would have been hidden behind native method calls are now expressed directly in Java code. Modern Java idioms can also be used; for example, streams can allow multiple threads to copy data between on-heap and off-heap memory in parallel.

Class-File API (Preview)

In https://openjdk.org/jeps/457

Provide a standard API for parsing, generating, and transforming Java class files.

Structured Concurrency (Second Preview)

In https://openjdk.org/jeps/462.

For example,

<T> List<Future<T>> executeAll(List<Callable<T>> tasks)
        throws InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
          List<? extends Supplier<Future<T>>> futures = tasks.stream()
              .map(task -> asFuture(task))
              .map(scope::fork)
              .toList();
          scope.join();
          return futures.stream().map(Supplier::get).toList();
    }
}

static <T> Callable<Future<T>> asFuture(Callable<T> task) {
   return () -> {
       try {
           return CompletableFuture.completedFuture(task.call());
       } catch (Exception ex) {
           return CompletableFuture.failedFuture(ex);
       }
   };
}

Scoped Values (Second Preview)

In https://openjdk.org/jeps/464.

For example,

class Framework {
    private final static ScopedValue<FrameworkContext> CONTEXT 
                        = ScopedValue.newInstance();   // (1)

    void serve(Request request, Response response) {
        var context = createContext(request);
        ScopedValue.where(CONTEXT, context)            // (2)
                   .run(() -> Application.handle(request, response));
    }

    public PersistedObject readKey(String key) {
        var context = CONTEXT.get();            // (3)
        var db = getDBConnection(context);
        db.readKey(key);
    }

    ...
}

Vector API (Seventh Incubator)

In https://openjdk.org/jeps/460.

Introduce an API to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPU architectures, thus achieving performance superior to equivalent scalar computations.

Here is a simple scalar computation over elements of arrays:

void scalarComputation(float[] a, float[] b, float[] c) {
   for (int i = 0; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
   }
}

Here is an equivalent vector computation, using the Vector API:

static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

void vectorComputation(float[] a, float[] b, float[] c) {
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
    for (; i < upperBound; i += SPECIES.length()) {
        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i);
        var vb = FloatVector.fromArray(SPECIES, b, i);
        var vc = va.mul(va)
                   .add(vb.mul(vb))
                   .neg();
        vc.intoArray(c, i);
    }
    for (; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
    }
}

Region Pinning for G1

In https://openjdk.org/jeps/423.

Reduce latency by implementing region pinning in G1, so that garbage collection need not be disabled during Java Native Interface (JNI) critical regions..

Pinning regions during minor collection operations, we aim to achieve the above goals by extending G1 to pin arbitrary regions during both major and minor collection operations, as follows:

• Maintain a count of the number of critical objects in each region: Increment it when a critical object in that region is obtained, and decrement it when that object is released. When the count is zero then garbage-collect the region normally; when the count is non-zero, consider the region to be pinned.

• During a major collection, do not evacuate any pinned region.

• During a minor collection, treat pinned regions in the young generation as having failed evacuation, thus promoting them to the old generation. Do not evacuate existing pinned regions in the old generation.

• Once we have done this then we can implement JNI critical regions — without disabling GC — by pinning regions that contain critical objects and continuing to collect garbage in unpinned regions.

Launch Multi-File Source-Code Programs

In https://openjdk.org/jeps/458.

Enhance the java application launcher to be able to run a program supplied as multiple files of Java source code. This will make the transition from small programs to larger ones more gradual, enabling developers to choose whether and when to go to the trouble of configuring a build tool.

For example, suppose a directory contains two small programs plus a helper class, alongside some library JAR files:

Prog1.java
Prog2.java
Helper.java
library1.jar
library2.jar

You can quickly run these programs by passing --class-path '*' to the java launcher:

$ java --class-path '*' Prog1.java
$ java --class-path '*' Prog2.java

JDK21

Record Patterns

Enhance the Java programming language with record patterns to deconstruct record values. Record patterns and type patterns can be nested to enable a powerful, declarative, and composable form of data navigation and processing.

• Support deconstruct record values

  As of Java 16, it supports pattern match with record value.

  Java

  record Point(int x, int y) {}
  
  static void printSum(Object obj) {
      if (obj instanceof Point p) {
          int x = p.x();
          int y = p.y();
          System.out.println(x+y);
      }
  }
  

  As of Java 21, it supports to deconstruct record values.

  Java

  // As of Java 21
  static void printSum(Object obj) {
      if (obj instanceof Point(int x, int y)) {
          System.out.println(x+y);
      }
  }
  

  * Nested record patterns
  Java

  record Point(int x, int y) {}
  enum Color { RED, GREEN, BLUE }
  record ColoredPoint(Point p, Color c) {}
  record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}
  
  // as of Java 21, we can extract the Rectangle record's values
  static void printUpperLeftColoredPoint(Rectangle r) {
      if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
          System.out.println(ul.c());
      }
  }
  
  // event, extract the ColoredPoint values
  static void printColorOfUpperLeftPoint(Rectangle r) {
      if (r instanceof Rectangle(ColoredPoint(Point p, Color c),
                              ColoredPoint lr)) {
          System.out.println(c);
      }
  }
  
  // or with var
  static void printXCoordOfUpperLeftPointWithPatterns(Rectangle r) {
      if (r instanceof Rectangle(ColoredPoint(Point(var x, var y), var c),
                              var lr)) {
          System.out.println("Upper-left corner: " + x);
      }
  }
  

• Record patterns and exhaustive switch

  JEP 441 enhances both switch expressions and switch statements to support pattern labels. Both switch expressions and pattern switch statements must be exhaustive: The switch block must have clauses that deal with all possible values of the selector expression. For pattern labels this is determined by analysis of the types of the patterns; for example, the case label case Bar b matches values of type Bar and all possible subtypes of Bar.

  With pattern labels involving record patterns, the analysis is more complex since we must consider the types of the component patterns and make allowances for sealed hierarchies. For example, consider the declarations:

  Java

  class A {}
  class B extends A {}
  sealed interface I permits C, D {}
  final class C implements I {}
  final class D implements I {}
  record Pair<T>(T x, T y) {}
  
  Pair<A> p1;
  Pair<I> p2;
  The following switch is not exhaustive, since there is no match for a pair containing two values both of type A:
  
  // As of Java 21
  switch (p1) {                 // Error!
      case Pair<A>(A a, B b) -> ...
      case Pair<A>(B b, A a) -> ...
  }
  These two switches are exhaustive, since the interface I is sealed and so the types C and D cover all possible instances:
  
  // As of Java 21
  switch (p2) {
      case Pair<I>(I i, C c) -> ...
      case Pair<I>(I i, D d) -> ...
  }
  
  switch (p2) {
      case Pair<I>(C c, I i) -> ...
      case Pair<I>(D d, C c) -> ...
      case Pair<I>(D d1, D d2) -> ...
  }
  In contrast, this switch is not exhaustive since there is no match for a pair containing two values both of type D:
  
  // As of Java 21
  switch (p2) {                        // Error!
      case Pair<I>(C fst, D snd) -> ...
      case Pair<I>(D fst, C snd) -> ...
      case Pair<I>(I fst, C snd) -> ...
  }
  

Pattern Matching for switch

Enhance the Java programming language with pattern matching for switch expressions and statements. Extending pattern matching to switch allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely.

• Support switch for pattern match

  Java

  // Prior to Java 21
  static String formatter(Object obj) {
      String formatted = "unknown";
      if (obj instanceof Integer i) {
          formatted = String.format("int %d", i);
      } else if (obj instanceof Long l) {
          formatted = String.format("long %d", l);
      } else if (obj instanceof Double d) {
          formatted = String.format("double %f", d);
      } else if (obj instanceof String s) {
          formatted = String.format("String %s", s);
      }
      return formatted;
  }
  
  // As of Java 21
  static String formatterPatternSwitch(Object obj) {
      return switch (obj) {
          case Integer i -> String.format("int %d", i);
          case Long l    -> String.format("long %d", l);
          case Double d  -> String.format("double %f", d);
          case String s  -> String.format("String %s", s);
          default        -> obj.toString();
      };
  }
  

• Support null for patten match

  Java

  // Prior to Java 21
  static void testFooBarOld(String s) {
      if (s == null) {
          System.out.println("Oops!");
          return;
      }
      switch (s) {
          case "Foo", "Bar" -> System.out.println("Great");
          default           -> System.out.println("Ok");
      }
  }
  
  // As of Java 21
  static void testFooBarNew(String s) {
      switch (s) {
          case null         -> System.out.println("Oops");
          case "Foo", "Bar" -> System.out.println("Great");
          default           -> System.out.println("Ok");
      }
  }
  

• Case refinement with when keyword

  Java

  // As of Java 21
  static void testStringOld(String response) {
      switch (response) {
          case null -> { }
          case String s -> {
              if (s.equalsIgnoreCase("YES"))
                  System.out.println("You got it");
              else if (s.equalsIgnoreCase("NO"))
                  System.out.println("Shame");
              else
                  System.out.println("Sorry?");
          }
      }
  }
  
  // As of Java 21
  static void testStringNew(String response) {
      switch (response) {
          case null -> { }
          case String s
          when s.equalsIgnoreCase("YES") -> {
              System.out.println("You got it");
          }
          case String s
          when s.equalsIgnoreCase("NO") -> {
              System.out.println("Shame");
          }
          case String s -> {
              System.out.println("Sorry?");
          }
      }
  }
  
  //  with extra rules for other known constant strings:
  static void testStringEnhanced(String response) {
      switch (response) {
          case null -> { }
          case "y", "Y" -> {
              System.out.println("You got it");
          }
          case "n", "N" -> {
              System.out.println("Shame");
          }
          case String s
          when s.equalsIgnoreCase("YES") -> {
              System.out.println("You got it");
          }
          case String s
          when s.equalsIgnoreCase("NO") -> {
              System.out.println("Shame");
          }
          case String s -> {
              System.out.println("Sorry?");
          }
      }
  }
  

• Switches and enum constants

  The use of enum constants in case labels is, at present, highly constrained: The selector expression of the switch must be of the enum type, and the labels must be simple names of the enum's constants. For example:

  Java

  // Prior to Java 21
  public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }
  
  static void testforHearts(Suit s) {
      switch (s) {
          case HEARTS -> System.out.println("It's a heart!");
          default -> System.out.println("Some other suit");
      }
  }
  

  Even after adding pattern labels, this constraint leads to unnecessarily verbose code. For example:

  Java

  // As of Java 21
  sealed interface CardClassification permits Suit, Tarot {}
  public enum Suit implements CardClassification { CLUBS, DIAMONDS, HEARTS, SPADES }
  final class Tarot implements CardClassification {}
  
  static void exhaustiveSwitchWithoutEnumSupport(CardClassification c) {
      switch (c) {
          case Suit s when s == Suit.CLUBS -> {
              System.out.println("It's clubs");
          }
          case Suit s when s == Suit.DIAMONDS -> {
              System.out.println("It's diamonds");
          }
          case Suit s when s == Suit.HEARTS -> {
              System.out.println("It's hearts");
          }
          case Suit s -> {
              System.out.println("It's spades");
          }
          case Tarot t -> {
              System.out.println("It's a tarot");
          }
      }
  }
  

  This code would be more readable if we could have a separate case for each enum constant rather than lots of guarded patterns. We therefore relax the requirement that the selector expression be of the enum type and we allow case constants to use qualified names of enum constants. This allows the above code to be rewritten as:

  Java

  // As of Java 21
  static void exhaustiveSwitchWithBetterEnumSupport(CardClassification c) {
      switch (c) {
          case Suit.CLUBS -> {
              System.out.println("It's clubs");
          }
          case Suit.DIAMONDS -> {
              System.out.println("It's diamonds");
          }
          case Suit.HEARTS -> {
              System.out.println("It's hearts");
          }
          case Suit.SPADES -> {
              System.out.println("It's spades");
          }
          case Tarot t -> {
              System.out.println("It's a tarot");
          }
      }
  }
  

  There are five major language design areas to consider when supporting patterns in switch:

  • Enhanced type checking
  • Exhaustiveness of switch expressions and statements
  • Scope of pattern variable declarations
  • Dealing with null
  • Errors

  https://openjdk.org/jeps/441

String Templates (Preview)

In https://openjdk.org/jeps/430.

Java doesn't choose a Javascript way to interpolate string,

const title = "My Web Page";
const text  = "Hello, world";

var html = `<html>
            <head>
                <title>${title}</title>
            </head>
            <body>
                <p>${text}</p>
            </body>
            </html>`;

String interpolation is dangerous, especially for SQL.

• The STR template processor

  Java

  // Embedded expressions can be strings
  String firstName = "Bill";
  String lastName  = "Duck";
  String fullName  = STR."\{firstName} \{lastName}";
  | "Bill Duck"
  String sortName  = STR."\{lastName}, \{firstName}";
  | "Duck, Bill"
  
  // Embedded expressions can perform arithmetic
  int x = 10, y = 20;
  String s = STR."\{x} + \{y} = \{x + y}";
  | "10 + 20 = 30"
  
  // Embedded expressions can invoke methods and access fields
  String s = STR."You have a \{getOfferType()} waiting for you!";
  | "You have a gift waiting for you!"
  String t = STR."Access at \{req.date} \{req.time} from \{req.ipAddress}";
  | "Access at 2022-03-25 15:34 from 8.8.8.8"
  
  //The template expression STR."..." is a shortcut for invoking the process method of the STR template processor. That is, the //////now-familiar example:
  
  String name = "Joan";
  String info = STR."My name is \{name}";
  //is equivalent to:
  
  String name = "Joan";
  StringTemplate st = RAW."My name is \{name}";
  String info = STR.process(st);
  

• Multi-line template expressions

  Java

  String title = "My Web Page";
  String text  = "Hello, world";
  String html = STR."""
          <html>
          <head>
              <title>\{title}</title>
          </head>
          <body>
              <p>\{text}</p>
          </body>
          </html>
          """;
  | """
  | <html>
  |   <head>
  |     <title>My Web Page</title>
  |   </head>
  |   <body>
  |     <p>Hello, world</p>
  |   </body>
  | </html>
  | """
  
  String name    = "Joan Smith";
  String phone   = "555-123-4567";
  String address = "1 Maple Drive, Anytown";
  String json = STR."""
      {
          "name":    "\{name}",
          "phone":   "\{phone}",
          "address": "\{address}"
      }
      """;
  | """
  | {
  |     "name":    "Joan Smith",
  |     "phone":   "555-123-4567",
  |     "address": "1 Maple Drive, Anytown"
  | }
  | """
  
  record Rectangle(String name, double width, double height) {
      double area() {
          return width * height;
      }
  }
  Rectangle[] zone = new Rectangle[] {
      new Rectangle("Alfa", 17.8, 31.4),
      new Rectangle("Bravo", 9.6, 12.4),
      new Rectangle("Charlie", 7.1, 11.23),
  };
  String table = STR."""
      Description  Width  Height  Area
      \{zone[0].name}  \{zone[0].width}  \{zone[0].height}     \{zone[0].area()}
      \{zone[1].name}  \{zone[1].width}  \{zone[1].height}     \{zone[1].area()}
      \{zone[2].name}  \{zone[2].width}  \{zone[2].height}     \{zone[2].area()}
      Total \{zone[0].area() + zone[1].area() + zone[2].area()}
      """;
  | """
  | Description  Width  Height  Area
  | Alfa  17.8  31.4     558.92
  | Bravo  9.6  12.4     119.03999999999999
  | Charlie  7.1  11.23     79.733
  | Total 757.693
  | """
  

• The FMT template processor

  FMT is another template processor defined in the Java Platform. FMT is like STR in that it performs interpolation, but it also interprets format specifiers which appear to the left of embedded expressions. The format specifiers are the same as those defined in java.util.Formatter. Here is the zone table example, tidied up by format specifiers in the template:

  Java

  record Rectangle(String name, double width, double height) {
      double area() {
          return width * height;
      }
  }
  Rectangle[] zone = new Rectangle[] {
      new Rectangle("Alfa", 17.8, 31.4),
      new Rectangle("Bravo", 9.6, 12.4),
      new Rectangle("Charlie", 7.1, 11.23),
  };
  String table = FMT."""
      Description     Width    Height     Area
      %-12s\{zone[0].name}  %7.2f\{zone[0].width}  %7.2f\{zone[0].height}     %7.2f\{zone[0].area()}
      %-12s\{zone[1].name}  %7.2f\{zone[1].width}  %7.2f\{zone[1].height}     %7.2f\{zone[1].area()}
      %-12s\{zone[2].name}  %7.2f\{zone[2].width}  %7.2f\{zone[2].height}     %7.2f\{zone[2].area()}
      \{" ".repeat(28)} Total %7.2f\{zone[0].area() + zone[1].area() + zone[2].area()}
      """;
  | """
  | Description     Width    Height     Area
  | Alfa            17.80    31.40      558.92
  | Bravo            9.60    12.40      119.04
  | Charlie          7.10    11.23       79.73
  |                              Total  757.69
  | """
  

• Safely composing and executing database queries

  The template processor class below, QueryBuilder, first creates a SQL query string from a string template. It then creates a JDBC PreparedStatement from that query string and sets its parameters to the values of the embedded expressions.

  Java

  record QueryBuilder(Connection conn)
  implements StringTemplate.Processor<PreparedStatement, SQLException> {
  
      public PreparedStatement process(StringTemplate st) throws SQLException {
          // 1. Replace StringTemplate placeholders with PreparedStatement placeholders
          String query = String.join("?", st.fragments());
  
          // 2. Create the PreparedStatement on the connection
          PreparedStatement ps = conn.prepareStatement(query);
  
          // 3. Set parameters of the PreparedStatement
          int index = 1;
          for (Object value : st.values()) {
              switch (value) {
                  case Integer i -> ps.setInt(index++, i);
                  case Float f   -> ps.setFloat(index++, f);
                  case Double d  -> ps.setDouble(index++, d);
                  case Boolean b -> ps.setBoolean(index++, b);
                  default        -> ps.setString(index++, String.valueOf(value));
              }
          }
  
          return ps;
      }
  }
  

  If we instantiate this hypothetical QueryBuilder for a specific Connection:

  Java

  var DB = new QueryBuilder(conn);
  

  then instead of the unsafe, injection-attack-prone code
  Java

  String query = "SELECT * FROM Person p WHERE p.last_name = '" + name + "'";
  ResultSet rs = conn.createStatement().executeQuery(query);
  

  we can write the more secure and more readable code

  Java

  PreparedStatement ps = DB."SELECT * FROM Person p WHERE p.last_name = \{name}";
  ResultSet rs = ps.executeQuery();
  

Unnamed Patterns and Variables

• The unnamed pattern

  In https://openjdk.org/jeps/443.

  Supports _ keyword for unnamed Patterns and Variables. For example, ... instanceof Point(_, int y) is legal, but these are not:

  • r instanceof _
  • r instanceof _(int x, int y)
  Java

  if (r instanceof ColoredPoint(Point(int x, int y), _)) { ... x ... y ... }
  
  if (r instanceof ColoredPoint(_, Color c)) { ... c ... }
  
  if (r instanceof ColoredPoint(Point(int x, _), _)) { ... x ... }
  

  * Unnamed pattern variables

  An unnamed pattern variable can appear in any type pattern, whether the type pattern appears at the top level or is nested in a record pattern. For example, both of these appearances are legal:

  • r instanceof Point _
  • r instanceof ColoredPoint(Point(int x, int _), Color _)

  By allowing us to elide names, unnamed pattern variables make run-time data exploration based on type patterns visually clearer, especially when used in switch statements and expressions.

  Unnamed pattern variables are particularly helpful when a switch executes the same action for multiple cases. For example, the earlier Box and Ball code can be rewritten as:

  Java

  switch (b) {
      case Box(RedBall _), Box(BlueBall _) -> processBox(b);
      case Box(GreenBall _)                -> stopProcessing();
      case Box(_)                          -> pickAnotherBox();
  }
  

  The first two cases use unnamed pattern variables because their right-hand sides do not use the Box's component. The third case, which is new, uses the unnamed pattern in order to match a Box with a null component.

  A case label with multiple patterns can have a guard. A guard governs the case as a whole, rather than the individual patterns. For example, assuming that there is an int variable x, the first case of the previous example could be further constrained:

  case Box(RedBall _), Box(BlueBall _) when x == 42 -> processBox(b); Pairing a guard with each pattern is not allowed, so this is prohibited:

  case Box(RedBall _) when x == 0, Box(BlueBall _) when x == 42 -> processBox(b); The unnamed pattern is shorthand for the type pattern var _. Neither the unnamed pattern nor var _ may be used at the top level of a pattern, so all of these are prohibited:

  • ... instanceof _
  • ... instanceof var _
  • case _
  • case var _

• Unnamed variables

  The following kinds of declarations can introduce either a named variable (denoted by an identifier) or an unnamed variable (denoted by an underscore):

  • A local variable declaration statement in a block (JLS 14.4.2),
  • A resource specification of a try-with-resources statement (JLS 14.20.3),
  • The header of a basic for statement (JLS 14.14.1),
  • The header of an enhanced for loop (JLS 14.14.2),
  • An exception parameter of a catch block (JLS 14.20), and
  • A formal parameter of a lambda expression (JLS 15.27.1).

  (The possibility of an unnamed local variable being declared by a pattern, i.e., a pattern variable (JLS 14.30.1), was covered above.)

  Declaring an unnamed variable does not place a name in scope, so the variable cannot be written or read after it has been initialized. An initializer must be provided for an unnamed variable in each kind of declaration above.

  An unnamed variable never shadows any other variable, since it has no name, so multiple unnamed variables can be declared in the same block.

  Here are the examples from above, modified to use unnamed variables.

  An enhanced for loop with side effects:

  Java

  int acc = 0;
  for (Order _ : orders) {
      if (acc < LIMIT) { 
          ... acc++ ...
      }
  }
  

  The initialization of a basic for loop can also declare unnamed local variables:
  Java

  for (int i = 0, _ = sideEffect(); i < 10; i++) { ... i ... }
  

  An assignment statement, where the result of the expression on the right hand side is not needed:

  Java

  Queue<Integer> q = ... // x1, y1, z1, x2, y2, z2, ...
  while (q.size() >= 3) {
  var x = q.remove();
  var y = q.remove();
  var _ = q.remove();
  ... new Point(x, y) ...
  }
  

  If the program needed to process only the x1, x2, etc., coordinates then unnamed variables could be used in multiple assignment statements:

  Java

  while (q.size() >= 3) {
      var x = q.remove();
      var _ = q.remove();
      var _ = q.remove(); 
      ... new Point(x, 0) ...
  }
  

  A catch block:

  Java

  String s = ...
  try { 
      int i = Integer.parseInt(s);
      ... i ...
  } catch (NumberFormatException _) { 
      System.out.println("Bad number: " + s);
  }
  

  Unnamed variables can be used in multiple catch blocks:
  Java

  try { ... } 
  catch (Exception _) { ... } 
  catch (Throwable _) { ... }
  

  In try-with-resources:

  Java

  try (var _ = ScopedContext.acquire()) {
      ... no use of acquired resource ...
  }
  

  A lambda whose parameter is irrelevant:
  Java

  ...stream.collect(Collectors.toMap(String::toUpperCase, _ -> "NODATA"))