Interview Questions and Answers

Java 21 is finally released on 19-Sep-2023 as the next long-term support (LTS) release of Oracle’s standard Java implementation.

The new features of Java 21 are as follows:

• String Templates (Preview) [JEP-430]
• Sequenced Collections [JEP-431]
• Generational ZGC [JEP-439]
• Record Patterns [JEP-440]
• Pattern Matching for switch [JEP-441]
• Foreign Function & Memory API (Third Preview) [JEP-442]
• Unnamed Patterns and Variables (Preview) [JEP-443]
• Virtual Threads [JEP-444]
• Unnamed Classes and Instance Main Methods (Preview) [JEP-445]
• Scoped Values (Preview) [JEP-446]
• Vector API (Sixth Incubator) [JEP-448]
• Deprecate the Windows 32-bit x86 Port for Removal [JEP-449]
• Prepare to Disallow the Dynamic Loading of Agents [JEP-451]
• Key Encapsulation Mechanism API [JEP-452]
• Structured Concurrency (Preview) [JEP-453]

String templates, which are scheduled to be introduced as a preview feature in JDK 21, aim to simplify the process of string formatting and manipulation in Java. This feature enables developers to incorporate expressions directly within string literals, thus facilitating the creation and formatting of intricate strings. In the following blog post, we will delve into the concept of string templates, offering practical illustrations that will assist Java developers in embracing and harnessing the capabilities of this potent addition.

Example:

Consider a scenario where you want to display a product’s information, including its name, price, and availability status. Traditionally, you might concatenate multiple strings using the + operator:

// Prior to Java 21
String productName = "Pen";
double productPrice = 30.99;
boolean productAvailable = true;

String productInfo = "Product: " + productName + "\nPrice: $" + productPrice + "\nAvailability: " + (productAvailable ? "In Stock" : "Out of Stock");

System.out.println(productInfo);

With string templates, you can simplify the formatting process and make the code more readable:

// As of Java 21
String productName = "Pen";
double productPrice = 30.99;
boolean productAvailable = true;

String productInfo = `Product: ${productName}
Price: $${productPrice}
Availability: ${productAvailable ? "In Stock" : "Out of Stock"}`;

System.out.println(productInfo);

In JDK 21, the introduction of Sequenced Collections brings new interfaces and methods to simplify and streamline collection processing. This enhancement aims to address common scenarios where accessing the first and last elements of various collection types in Java required non-uniform and sometimes cumbersome approaches. This article explores the Sequenced Collections functionality and its benefits through examples of different collection processing scenarios.

Sequenced Collections introduces three new interfaces:

• SequencedSet
• SequencedCollection
• SequencedMap

These interfaces come with additional methods that provide improved access and manipulation capabilities for collections.

Here is an example of accessing the First and Last Element in Java 21:

Prior to JDK 21, retrieving the first and last elements of collections in Java involved different methods and approaches depending on the collection type. Let’s examine some examples of accessing the first and last elements using the pre-JDK 21 JDK API calls:

For List:
First Element: list.get(0)
Last Element: list.get(list.size()-1)

For Deque:
First Element: deque.getFirst()
Last Element: deque.getLast()

For Set:
First Element: set.iterator().next() or set.stream().findFirst().get()
Last Element: requires iterating through the set

For SortedSet:
First Element: set.first()
Last Element: set.last()

With the introduction of JDK 21 and the Sequenced Collections feature, accessing the first and last elements becomes more consistent and straightforward. The new methods simplify the process across different collection types:

For List, Deque, Set:
First Element: collection.getFirst()
Last Element: collection.getLast()

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.

Example of Pattern matching and records:

// As of Java 16
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);
  }
}

Updates in Java 21:

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

Enhanced 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.

// 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;
}

Updates in Java 21:

// 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();
  };
}

You can download Java 21 from Oracle website: Download Java 21

Here is the Java 21 documentation link: Java 21 Documentation

JDK 21 will receive updates under the NFTC, until September 2026, a year after the release of the next LTS. Subsequent JDK 21 updates will be licensed under the Java SE OTN License (OTN) and production use beyond the limited free grants of the OTN license will require a fee.