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.

Virtual threads are JVM-managed lightweight threads that will help in writing high-throughput concurrent applications (throughput means how many units of information a system can process in a given amount of time). [JEP-425, JEP-436 and JEP-444] In Java 21, virtual threads are ready for production use.

With the introduction of virtual threads, it becomes possible to execute millions of virtual threads using only a few operating system threads. The most advantageous aspect is that there is no need to modify existing Java code. All that is required is instructing our application framework to utilize virtual threads in place of platform threads.

To create a virtual thread, using the Java APIs, we can use the Thread or Executors.

Example:

Runnable runnable = () -> System.out.println("Inside Runnable");

//1

Thread.startVirtualThread(runnable);

//2

Thread virtualThread = Thread.ofVirtual().start(runnable);

//3

var executor = Executors.newVirtualThreadPerTaskExecutor(); 

executor.submit(runnable);

It is common in some other programming languages (such as Python, Scala) that we can skip naming a variable that we will not use in the future.

Example:

public void print(Object o) {

  switch (o) {

    case Point(int x, int _) -> System.out.printf("The x position is : %d%n", x); // Prints only x

    //...

  }

}

In Java, unnamed modules and packages are a familiar concept. When we do not create a module-info.java class then the module is automatically assumed by the compiler. Similarly, if we do not add the package statement in the class in the root directory, the class just compiles and runs fine.

Same way, we can now create unnamed classes. Quite obviously, an unnamed class is a class without a name.

Example:

// Prior to Java 21

public class TestAConcept {

  public static void main(String[] args) {

    System.out.println(method());

  }

  static String method() {

    //...

  }

}

From Java 21, we can write the above class without the class declaration as follows. It removes the class declaration, public and static access modifiers etc. to have a cleaner class.

// In Java 21

void main(String[] args) {

  System.out.println(method());

}

String method() {

  //...

}

If you are familiar with ThreadLocal variables, the scoped values are a modern way of sharing data within and across threads. Scoped values allow a value (object) to be stored for a limited time in such a way that only the thread that wrote the value can read it.

Scoped values are usually created as public static fields so we can access them directly without passing them as a parameter to any method. However, it is important to understand that if the value is checked in multiple methods, the current value will depend on the execution time and state of the thread. The value may change over time when accessed over time in different methods.

To create scoped values, use the ScopedValue.newInstance() factory method.

public final static ScopedValue<USER> LOGGED_IN_USER = ScopedValue.newInstance();

To create scoped values, use the ScopedValue.newInstance() factory method.

public final static ScopedValue<USER> LOGGED_USER = ScopedValue.newInstance();

With ScopedValue.where(), we bind the scoped value to the object instance; and then we run a method, for whose call duration the scoped value should be valid. Note that a scoped value is written once and is then immutable, thus nobody can change the loggedInUser in the invoked method.

class LoginUtil {

 

public final static ScopedValue<USER> LOGGED_USER = ScopedValue.newInstance();

 

  //Inside some method

  User loggedInUser = authenticateUser(request);

  ScopedValue.where(LOGGED_USER, loggedInUser).run(() -> service.getData());

}

Inside the invoked thread, we can directly access the scoped value:

public void getData() {

 

  User loggedInUser = LoginUtil.LOGGED_USER.get();

  //use loggedUser

}

The structured concurrency feature aims to simplify Java concurrent programs by treating multiple tasks running in different threads (forked from the same parent thread) as a single unit of work. Treating all such child threads as a single unit will help in managing all threads as a unit; thus, canceling and error handling can be done more reliably.

In structured multi-threaded code, if a task splits into concurrent subtasks, they all return to the same place i.e., the task’s code block. This way, the lifetime of a concurrent subtask is confined to that syntactic block.

In this approach, subtasks work on behalf of a task that awaits their results and monitors them for failures. At run time, structured concurrency builds a tree-shaped hierarchy of tasks, with sibling subtasks being owned by the same parent task. This tree can be viewed as the concurrent counterpart to the call stack of a single thread with multiple method calls.

In this approach, subtasks work on behalf of a task that awaits their results and monitors them for failures. At run time, structured concurrency builds a tree-shaped hierarchy of tasks, with sibling subtasks being owned by the same parent task. This tree can be viewed as the concurrent counterpart to the call stack of a single thread with multiple method calls.

try (var scope = new StructuredTaskScope.ShutdownOnFailure()()) {

 

    Future<AccountDetails> accountDetailsFuture = scope.fork(() -> getAccountDetails(id));

    Future<LinkedAccounts> linkedAccountsFuture = scope.fork(() -> fetchLinkedAccounts(id));

    Future<DemographicData> userDetailsFuture = scope.fork(() -> fetchUserDetails(id));

 

    scope.join(); // Join all subtasks created

    scope.throwIfFailed(e -> new WebApplicationException(e));

 

    //The subtasks have completed by now so process the result

    return new Response(accountDetailsFuture.resultNow(), 

    linkedAccountsFuture.resultNow(),

    userDetailsFuture.resultNow());

}

GraalVM for JDK 21 binaries are free to use in production and free to redistribute, at no cost, under the GraalVM Free Terms and Conditions (GFTC).

GraalVM for JDK 21 will receive updates under the GFTC, until September 2026, a year after the release of the next LTS. Subsequent updates of GraalVM for JDK 21 will be licensed under the GraalVM OTN License Including License for Early Adopter Versions (GOTN) and production use beyond the limited free grants of the GraalVM OTN license will require a fee.

Oracle GraalVM uses the Graal just-in-time compiler and includes the Native Image feature as optional early adopter technology.

You can download GraalVM for JDK 21 from Oracle website: Download GraalVM for JDK 21

Please check the details here on GraalVM for Java 21:

GraalVM for Java 21