Hi Everyone,

I am thrilled to take you on an exhilarating journey through the remarkable advancements spanning Java 9 to 21.

Note – Here I have highlighted only important features and skipped few features that has minor improvement across multiple versions.

Let’s drive in.

Java 9

Modular System (Project Jigsaw): In previous Java versions, code was organized into packages without a defined way to establish relationships and dependencies between them. The modular system in Java 9 changes all that by introducing a way to package and deliver Java applications as modules.

The modular system allows for greater flexibility in building smaller, manageable modules. Each module includes related packages, necessary resources, and metadata. Developers can specify which packages are public and accessible to other modules, and which ones should remain private.

Here are some benefits of the module system:

• Strong encapsulation: Modules can declare which packages and resources they export and require from other modules, preventing conflicts in code and making application development more manageable.
• Improved security: Modules can restrict access to resources, improving the security of Java applications.
• Reduced classpath complexity: The module system simplifies the management and resolution of module dependencies, thus reducing classpath complexity.
• Reduced application size: The module system allows developers to package only the modules they need, which ultimately reduces the size of Java applications.

JShell: Java read-eval-print loop (REPL), which was introduced in Java 9, is an interactive tool that lets you evaluate Java declarations, statements and expressions in real-time. It’s an excellent resource for learning Java, prototyping Java code, and debugging Java applications.

Using JShell is easy – just launch it from the command line and start writing Java code. JShell will immediately evaluate the code as you type and display the results. You can even test the following Java statements using JShell:

JShell is a powerful and versatile tool for Java developers. It can be used for a variety of tasks, including:

• Learning the Java programming language
• Prototyping Java code
• Debugging Java applications
• Exploring new Java features
• Teaching Java to others

HTTP/2 Client: Java 9 introduces a new HTTP/2 Client API that supports the latest version of the HTTP protocol, offering improved performance, reduced overhead, and improved security for HTTP communication. The API is easy to use and provides asynchronous support, enabling HTTP requests without blocking the main thread of the application. It also supports multiple protocols, making it a suitable choice for applications that need to support various protocols.

To use the Java 9 HTTP/2 Client, you first need to import the jdk.incubator.httpclient module. Once you have imported the module, you can create a new HttpClient object. You can then use the HttpClient object to send HTTP requests and receive HTTP responses.

Here is an example of how to use the Java 9 HTTP/2 Client to send a simple HTTP GET request:

import jdk.incubator.httpclient.HttpClient;
import jdk.incubator.httpclient.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpResponse response = client.send(
                new HttpRequest.Builder()
                        .uri(URI.create("https://nikeshpathak.com"))
                        .method("GET")
                        .build(),
                HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

Try-With-Resources Improvement: Allowing effectively final variables to be used in try-with-resources.

Java 9’s Try-With-Resources Statement: Key Improvements

• Resources can be declared outside the try block.
  • Prior to Java 9, resources had to be declared inside the try block. Now, Java 9 permits resources to be defined outside the try block, allowing for more readable and maintainable code.
• Multiple resource types are supported.
  • In previous versions of Java, the try-with-resources statement could only be used with resources of the same type. The updated version supports multiple types of resources, making it simpler to implement the statement with complex code.
• Suppressed exceptions are no longer an issue
  • In Java 8 and earlier, exceptions thrown by resources were suppressed by the try-with-resources statement. However, in Java 9, these exceptions are no longer suppressed, leading to more efficient debugging.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        // Declare the resources outside the try block.
        BufferedReader reader = new BufferedReader(new FileReader("myfile.txt"));

        // Use the improved try-with-resources statement to close the reader.
        try (reader) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

Private method in interface. –
Java 9 introduced the ability to declare private methods in interfaces. This feature allows interface designers to encapsulate common code and prevent implementers from overriding or modifying that code.

Java 9 Javadoc improvement:

• Support for HTML5: Javadoc now generates documentation in HTML5 format by default. This allows you to use modern HTML5 features in your documentation, such as CSS3 and JavaScript.
• Improved code highlighting: Javadoc now uses a new code highlighter that provides better support for Java 9 features, such as modules and private methods in interfaces.
• Support for linking to Java modules: Javadoc now supports linking to Java modules. This allows you to create documentation that is more modular and easier to navigate.
• Support for generating documentation for private methods: Javadoc now supports generating documentation for private methods. This can be useful for documenting implementation details that are not exposed to the public API.
• Improved support for generating documentation for nested classes: Javadoc now provides better support for generating documentation for nested classes. This makes it easier to document the relationships between nested classes and their outer classes.

Java 10

Local-Variable Type Inference (var): Java 10 introduced local-variable type inference, also known as var, which allows you to declare a local variable without specifying its type. The compiler will infer the type of the variable based on the value that is assigned to it.
example –

var myVariable = 10; // myVariable is inferred to be of type int
var myOtherVariable = "Hello, world!"; // myOtherVariable is inferred to be of type String

New APIs for process handling and file I/O: Java 10 introduced the following new APIs for process handling and file I/O:

Process handling: Java’s ProcessHandle class provides information about a running process, while the ProcessTree class represents a hierarchy of running processes. ProcessInfo class offers details about a process, including the command line and user ID. The Process#destroyForcibly() method terminates a process and its child processes.

File I/O: Java’s File Handling API has several useful classes and methods, including PathMatcher for matching file paths, WatchService for detecting file changes, and FileChannel methods like newByteChannel(), newInputStream(), newOutputStream(), and newMappedByteBuffer().

These new APIs provide a number of benefits, including:

• Improved process handling: The new process handling APIs provide more information about running processes and make it easier to manage running processes.
• More efficient file I/O: The new file I/O APIs provide more efficient ways to read and write files.
• Support for new file system features: The new file I/O APIs support new file system features, such as watching for changes to files and directories.

Garbage Collector Interface: Java 10 introduced the Garbage Collector (GC) Interface, which is a new interface that allows garbage collectors to be plugged in and out of the Java Virtual Machine (JVM) at runtime. This makes it easier to develop and deploy new garbage collectors, as well as to switch between different garbage collectors depending on the needs of the application.

To use a different garbage collector, you can specify the garbage collector to use on the command line when you start the JVM. For example, to start the JVM using the ZGC, you would use the following command:

example –

java -XX:+UseZGC MyApplication

Java 11

HTTP Client Updates: Standardized the HTTP client API introduced in Java 9.

Local-Variable Syntax for Lambda Parameters: Similar to var, but for lambda expressions.

The local-variable syntax for lambda parameters in Java 11 is similar to the var keyword, but it is specifically for lambda expressions. It allows you to declare lambda parameters without specifying their type. The compiler will infer the type of the parameter based on the value that is assigned to it.

example –

(var a, var b) -> a + b; // a and b are inferred to be of type int

Nashorn JavaScript Engine Removal: The Nashorn JavaScript engine was removed in Java 11. This was done because Nashorn was deprecated in Java 9 and was not being actively maintained. The GraalVM JavaScript engine is now the recommended JavaScript engine for use with Java.

The GraalVM JavaScript engine is a more modern and performant JavaScript engine than Nashorn. It also supports a wider range of JavaScript features.

If you are using Nashorn in your Java code, you will need to migrate to the GraalVM JavaScript engine in order to continue using JavaScript in your Java applications.

Flight Recorder:JFR (Java Flight Recorder) was made available in this version without commercial license restrictions.

Java Flight Recorder (JFR) is a diagnostic and profiling tool that collects data about a running Java application. It is integrated into the Java Virtual Machine (JVM) and causes almost no performance overhead, so it can be used even in heavily loaded production environments.

JFR collects data about a variety of events, including:

• Garbage collection
• Memory allocation
• CPU usage
• I/O operations
• Exception handling
• Synchronization
• Method execution

JFR can be used to troubleshoot performance problems, identify memory leaks, and optimize code. It can also be used to collect data about the overall behavior of a Java application.

JFR data is stored in a binary format called JFR flight recording. JFR flight recordings can be analyzed using the Java Mission Control (JMC) tool. JMC provides a variety of features for analyzing JFR data, including:

• Timelines
• Charts
• Tables
• Filters
• Reports

JFR is a valuable tool for Java developers. It can be used to improve the performance, reliability, and scalability of Java applications.

Here are some of the benefits of using Java Flight Recorder:

• Comprehensive data collection: JFR collects a wide range of data about a running Java application. This data can be used to diagnose performance problems, identify memory leaks, and optimize code.
• Low overhead: JFR has a very low performance overhead, so it can be used even in heavily loaded production environments.
• Easy to use: JFR is easy to use and configure. It can be used to start and stop recording data with a single command-line option.
• Powerful analysis tools: JMC provides a variety of powerful tools for analyzing JFR data. This makes it easy to identify the root cause of performance problems and make the necessary changes to improve the performance of your application.

Overall, Java Flight Recorder is a powerful and versatile tool that can be used to improve the performance, reliability, and scalability of Java applications.

Nest-based access control: Nest-based access control (NAC) is a feature introduced in Java 11 that allows classes to access each other’s private members without the need for bridge methods. Bridge methods are automatically generated by the compiler when a nested class needs to access a private member of its enclosing class.

NAC simplifies the code generation process and eliminates the need for bridge methods, which can improve performance and reduce memory usage. It also makes it easier to develop and maintain modular code.

To use NAC, you simply need to declare the nested class within the enclosing class. The nested class will then be able to access the private members of its enclosing class without any restrictions.

Here is an example of NAC:

public class Outer {
    private int secret = 10;

    public class Inner {
        public void printSecret() {
            System.out.println(secret);
        }
    }
}

In this example, the Inner class is nested within the Outer class. The Inner class can access the secret variable of the Outer class even though it is private.

Dynamic class-file constant pool sharing: Java 11 introduced dynamic class-file constant pool sharing, which allows the Java Virtual Machine (JVM) to share constant pools between different classes. This can improve performance and reduce memory usage, especially for applications that load a large number of classes.

Prior to Java 11, each class had its own constant pool. This could lead to performance problems and increased memory usage, especially for applications that load a large number of classes.

With dynamic class-file constant pool sharing, the JVM can share constant pools between different classes. This is done by using a technique called constant pool deduplication.

Constant pool deduplication works by identifying identical constant pools in different classes. When the JVM finds two identical constant pools, it merges them into a single constant pool. This single constant pool is then shared by both classes.

Dynamic class-file constant pool sharing is a transparent feature. It does not require any changes to your Java code.

Here are some of the benefits of using dynamic class-file constant pool sharing:

• Improved performance: Dynamic class-file constant pool sharing can improve performance by reducing the number of constant pools that need to be loaded into memory and by reducing the number of times that the JVM needs to search for constant values in the constant pool.
• Reduced memory usage: Dynamic class-file constant pool sharing can reduce memory usage by reducing the amount of memory that is required to store constant pools.
• No code changes required: Dynamic class-file constant pool sharing is a transparent feature. It does not require any changes to your Java code.

Java 12

Switch Expressions (Preview): Java 12 introduced switch expressions, which are a more concise and expressive way to write switch statements. Switch expressions can be used to return a value, which makes them more flexible than traditional switch statements.

To use a switch expression, you simply need to use the switch keyword followed by the expression that you want to evaluate. The cases of the switch expression are then listed after the expression.

Here is an example of a switch expression:

int number = 10;
String result = switch (number) {
    case 10:
        yield "Ten";
    case 20:
        yield "Twenty";
    default:
        yield "Other";
};

Compact Number Formatting: Java 12 introduced compact number formatting, which allows you to format numbers in a more concise way. Compact number formatting is useful for applications where space is limited, such as GUI components and mobile apps.

Compact number formatting works by replacing large numbers with their abbreviated forms. For example, the number 123,456,789 can be formatted as “123M” or “123 million”.

To use compact number formatting, you can use the CompactNumberFormat class. The CompactNumberFormat class provides a number of methods for formatting numbers in a compact way.

For example, the following code formats the number 123,456,789 as “123M”:

CompactNumberFormat formatter = CompactNumberFormat.getInstance();
String formattedNumber = formatter.format(123456789);
System.out.println(formattedNumber);

Raw String Literals (Preview): Java 12 introduced raw string literals, which allow you to create string literals without any escape sequences. This can make your code more concise and readable, especially when you are working with strings that contain a lot of escape sequences.

To create a raw string literal, you simply need to prefix the string literal with a backslash (\) followed by a single quote (‘). For example, the following string literal is a raw string literal:

String configuration = "\'
[database]
host = localhost
port = 3306
database = my_database
username = root
password = password
'";

JFR improvements –

Java 12 introduced a number of improvements to Java Flight Recorder (JFR), including:

• New JFR Security Events: Four new JFR Security Events were introduced: jdk.SecurityPropertyModification, jdk.TLSHandshake, jdk.X509Validation, and jdk.X509Certificate. These events can be used to track security-related activities in your application.
• Improved JFR Configuration: A new interactive wizard was added to make it easier to create JFR configuration files. You can also now pass configuration values directly to the JFR command-line tool.
• Support for ZGC: JFR now supports Z Garbage Collector (ZGC), which is a new garbage collection algorithm that was introduced in Java 11.
• Improved JFR Performance: A number of performance improvements were made to JFR, including reducing the overhead of recording events and improving the performance of the JFR command-line tool.

New APIs for XML and JSON processing

Java 12 introduced the following new APIs for XML and JSON processing:

• XML:
  • XMLStreamWriter class: This class provides a streaming interface for writing XML data.
  • XMLStreamReader class: This class provides a streaming interface for reading XML data.
  • XMLParserFactory class: This class provides a factory for creating XML parsers.
• JSON:
  • JSONDecoder class: This class decodes JSON data into Java objects.
  • JSONEncoder class: This class encodes Java objects into JSON data.
  • JSONParserFactory class: This class provides a factory for creating JSON parsers.

Java 13

Text Blocks (Preview): Java 13 introduced text blocks, which are a new way to write multiline string literals. Text blocks are more concise and readable than traditional multiline string literals, and they also make it easier to avoid escape sequences.

To create a text block, you simply need to start the string literal with three double quotes (“””) and end it with another three double quotes. For example, the following code shows how to create a text block:

String textBlock = """
This is a text block.
and can avoid escape sequences.
"""";

New APIs for dynamic class loading and file system access –

• Dynamic class loading:
  • DynamicClassLoader class: This class provides a more flexible and powerful way to load classes dynamically.
  • ModuleReference class: This class represents a reference to a module.
  • ModuleFinder interface: This interface provides a way to find modules.
• File system access:
  • Path interface: This interface represents a path to a file or directory.
  • FileSystem interface: This interface represents a file system.
  • FileSystems class: This class provides a factory for creating file systems.

Java 14

Pattern Matching (Preview): Java 14 introduced pattern matching, which is a new way to compare and extract data from objects. Pattern matching is more concise and expressive than traditional conditional statements, and it can also help to reduce errors.

To use pattern matching, you simply need to use the switch statement followed by a pattern expression. The pattern expression can be any valid Java expression, such as a variable, a literal value, or a method call.

Here are some examples of pattern matching in Java:

// Match a nested pattern
Point point = new Point(10, 20);
String quadrant = switch (point) {
  case (0, 0):
    yield "Origin";
  case (x, y) where x > 0 && y > 0:
    yield "Quadrant I";
  case (x, y) where x < 0 && y > 0:
    yield "Quadrant II";
  case (x, y) where x < 0 && y < 0:
    yield "Quadrant III";
  case (x, y) where x > 0 && y < 0:
    yield "Quadrant IV";
  default:
    yield "Unknown";
};
//-----------------------------
// Match a regular expression
String name = "John Doe";
String title = switch (name) {
  case /\w+ \w+/:
    yield "Mr. " + name;
  default:
    yield "Unknown";
};
//---------------------------------
// Match a simple type
int number = 10;
String result = switch (number) {
  case 10:
    yield "Ten";
  case 20:
    yield "Twenty";
  default:
    yield "Other";
};

Records (Preview): Java 14 introduced records, which are a new type of class that is designed to represent immutable data. Records are simpler and more concise than traditional classes, and they can be used to represent a wide variety of data types, such as person objects, product objects, and address objects.

Records are declared using the record keyword. The record keyword takes the name of the record and the names of its fields as its arguments. For example

// Create a new Person record
Person person = Person.of("John Doe", 30);

// Get the person's name
String name = person.name();

// Get the person's age
int age = person.age();

// Check if two Person records are equal
boolean equal = person.equals(new Person("John Doe", 30));

// Sort a list of Person records
List<Person> people = List.of(
    Person.of("John Doe", 30),
    Person.of("Jane Doe", 25)
);
people.sort(Comparator.comparing(Person::name));

Sealed classes: Java 14 introduced sealed classes, which are a new type of class that can restrict its subclasses. Sealed classes are useful for modeling domain concepts and improving the security of libraries.

To seal a class, you simply need to add the sealed keyword to its declaration. Then, you can specify the permitted subclasses using the permits clause. For example, the following code declares a sealed class called Shape:

sealed class Shape permits Circle, Square, Rectangle {}

This code specifies that the only permitted subclasses of the Shape class are the Circle, Square, and Rectangle classes.

Sealed classes have a number of benefits, including:

• Improved domain modeling: Sealed classes can help you to improve your domain modeling by making it clear which classes are allowed to extend a given class.
• Reduced coupling: Sealed classes can help to reduce coupling between your classes by making it clear which classes are allowed to depend on each other.
• Improved security: Sealed classes can help to improve the security of your libraries by making it more difficult for attackers to introduce malicious subclasses.

Here are some examples of how to use sealed classes in Java:

// Create a new Shape object
Shape shape = new Square();

// Check if the shape is a Circle
boolean isCircle = shape instanceof Circle;

// Check if the shape is a Square
boolean isSquare = shape instanceof Square;

// Create a new subclass of the Shape class
public class Triangle extends Shape {} // This will not compile, because the Shape class is sealed

// Create a new permitted subclass of the Shape class
public class Triangle extends Shape permits Circle {} // This will compile, because the Shape class permits the Triangle subclass

Continue to the part-2

Thanks for reading. you can connect me @linkedin