New features between Java 8 and Java 21 New JDK tools and features since OpenJDK 8 ; Launching Java files as scripts. Flight recorder (data collection framework for troubleshooting) and many more.
Java Higher Versions and Features
Java SE 9 Features
Java SE 9, released in 2017, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 9.
1. Module System (Java Platform Module System)
Java SE 9 introduced the Module System, also known as the Java Platform Module System (JPMS). It allows developers to modularize their applications, making it easier to manage dependencies and encapsulate code. Modules provide a higher level of abstraction and allow for more fine-grained control over access and visibility of classes and resources. Here's an example:
module com.example.myapp {
requires java.base;
requires java.sql;
requires javafx.controls;
exports com.example.myapp.ui;
exports com.example.myapp.api to com.example.otherapp;
}
2. JShell (Java Shell)
JShell is an interactive command-line tool introduced in Java SE 9. It provides a Read-Eval-Print Loop (REPL) environment, allowing developers to experiment, evaluate, and test Java code snippets without the need for a full-fledged application or compilation. JShell offers a convenient way to quickly prototype code, explore APIs, and debug small code snippets. Here's an example:
jshell> int x = 5;
x ==> 5
jshell> int y = 10;
y ==> 10
jshell> int sum = x + y;
sum ==> 15
Conclusion
Java SE 9 introduced significant features such as the Module System and JShell, providing developers with improved modularity, encapsulation, and interactive programming capabilities. These features enhance the Java language and empower developers to write more maintainable and efficient code. Java SE 9 is a major release that brings valuable enhancements to the Java platform.
Java SE 10 Features
Java SE 10, released in 2018, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 10.
1. Local Variable Type Inference
Java SE 10 introduced local variable type inference, allowing developers to declare local variables without explicitly specifying their types. Instead, the compiler infers the variable type based on the assigned value. This feature reduces boilerplate code and enhances readability. Here's an example:
var message = "Hello, World!";
var count = 10;
var numbers = List.of(1, 2, 3, 4, 5);
2. Parallel Full GC for G1
Java SE 10 enhanced the Garbage-First (G1) garbage collector by introducing the Parallel Full GC feature. It enables parallel processing during the Full Garbage Collection phase, leading to improved garbage collection performance on systems with large heaps. This feature helps reduce garbage collection pauses and provides better overall application throughput.
Conclusion
Java SE 10 brought valuable features such as Local Variable Type Inference and Parallel Full GC for G1. Local Variable Type Inference simplifies coding by inferring variable types, while the Parallel Full GC improves garbage collection performance. These features enhance developer productivity and application performance in the Java ecosystem.
Java SE 11 Features
Java SE 11, released in 2018, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 11.
1. Local-Variable Syntax for Lambda Parameters
Java SE 11 introduced the ability to use the "var" keyword in lambda expressions, allowing developers to use a more concise syntax when working with lambda parameters. Instead of explicitly declaring the parameter type, the compiler infers it based on the context. This feature reduces verbosity and improves code readability. Here's an example:
// Before Java SE 11
Function<Integer, String> converter = (Integer num) -> String.valueOf(num);
// With Java SE 11
Function<Integer, String> converter = (var num) -> String.valueOf(num);
2. HTTP Client (Standardized HTTP Client API)
Java SE 11 introduced a new, standardized HTTP Client API that simplifies making HTTP requests and processing responses. This API provides a more modern and flexible approach to working with HTTP, including support for both synchronous and asynchronous operations, as well as features like HTTP/2 and WebSocket. Here's an example:
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/data"))
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
String responseBody = response.body();
Conclusion
Java SE 11 brought valuable features such as Local-Variable Syntax for Lambda Parameters and the HTTP Client API. Local-Variable Syntax for Lambda Parameters simplifies lambda expressions by allowing the "var" keyword for parameter types. The new HTTP Client API provides a modern and standardized approach to working with HTTP requests and responses. These features enhance developer productivity and improve the capabilities of Java for building robust applications.
Java SE 12 Features
Java SE 12, released in 2019, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 12.
1. Switch Expressions (Preview Feature)
Java SE 12 introduced a preview feature called Switch Expressions, which enhances the existing switch statement by allowing it to be used as an expression. This enables more concise and readable code, especially when dealing with multiple cases. Here's an example:
int dayOfWeek = 3;
String dayType = switch (dayOfWeek) {
case 1, 2, 3, 4, 5 -> "Weekday";
case 6, 7 -> "Weekend";
default -> "Unknown";
};
2. Compact Number Formatting
Java SE 12 introduced the Compact Number Formatting feature, which provides a more compact representation of numbers based on a given locale. This feature is useful for applications dealing with internationalization and localization. Here's an example:
NumberFormat formatter = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
String formattedNumber = formatter.format(1000000);
// Output: 1M
Conclusion
Java SE 12 brought valuable features such as Switch Expressions (Preview Feature) and Compact Number Formatting. Switch Expressions allow switch statements to be used as expressions, resulting in more concise code. Compact Number Formatting provides a compact representation of numbers for improved internationalization and localization support. These features enhance developer productivity and provide better support for modern application development in the Java ecosystem.
Java SE 13 Features
Java SE 13, released in 2019, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 13.
1. Text Blocks (Preview Feature)
Java SE 13 introduced a preview feature called Text Blocks, which simplifies the creation of multi-line string literals. Text Blocks provide a more readable and maintainable way to define strings with embedded line breaks and formatting. Here's an example:
String message = """
Hello,
This is a text block.
It supports multiple lines.
""";
2. Switch Expressions (Standard Feature)
Java SE 13 made the Switch Expressions feature, previously introduced as a preview feature in Java SE 12, a standard feature. Switch Expressions allow the switch statement to be used as an expression, enabling more concise and readable code. Here's an example:
String fruit = "apple";
int rating = switch (fruit) {
case "apple" -> 9;
case "banana" -> 8;
case "orange" -> 7;
default -> 0;
};
Conclusion
Java SE 13 brought valuable features such as Text Blocks (Preview Feature) and Switch Expressions (Standard Feature). Text Blocks simplify the creation of multi-line string literals, improving code readability. Switch Expressions, now a standard feature, allow the switch statement to be used as an expression, resulting in more concise code. These features enhance developer productivity and provide better support for modern application development in the Java ecosystem.
Java SE 14 Features
Java SE 14, released in 2020, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 14.
1. Records (Preview Feature)
Java SE 14 introduced a preview feature called Records, which provides a concise way to declare classes that are primarily used for holding data. Records automatically generate common methods such as constructors, accessors, and equals/hashCode methods based on the defined fields. Here's an example:
public record Person(String name, int age) { }
Person person = new Person("John Doe", 30);
String name = person.name();
int age = person.age();
2. Pattern Matching for instanceof (Preview Feature)
Java SE 14 introduced a preview feature called Pattern Matching for instanceof, which simplifies the common use case of casting an object to a specific type after checking its type with instanceof. It eliminates the need for explicit casting and provides a more concise syntax. Here's an example:
if (shape instanceof Circle circle) {
double radius = circle.getRadius();
// Perform circle-specific operations
}
Conclusion
Java SE 14 brought valuable features such as Records (Preview Feature) and Pattern Matching for instanceof (Preview Feature). Records provide a concise way to declare data-holding classes with automatically generated methods. Pattern Matching for instanceof simplifies the casting of objects to specific types, resulting in more readable code. These features enhance developer productivity and provide better support for modern application development in the Java ecosystem.
Java SE 15 Features
Java SE 15, released in 2020, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 15.
1. Sealed Classes (Preview Feature)
Java SE 15 introduced a preview feature called Sealed Classes, which allows developers to control the inheritance hierarchy of classes. Sealed classes define a limited set of subclasses that can extend them, providing better encapsulation and reducing the risk of unintended subclasses. Here's an example:
public sealed class Shape permits Circle, Rectangle, Triangle {
// Shape implementation
}
public final class Circle extends Shape {
// Circle implementation
}
2. Text Blocks (Standard Feature)
Java SE 15 made the Text Blocks feature, previously introduced as a preview feature in Java SE 13, a standard feature. Text Blocks provide a more readable and maintainable way to define strings with embedded line breaks and formatting. Here's an example:
String message = """
Hello,
This is a text block.
It supports multiple lines.
""";
Conclusion
Java SE 15 brought valuable features such as Sealed Classes (Preview Feature) and Text Blocks (Standard Feature). Sealed Classes provide better control over the inheritance hierarchy, enhancing encapsulation and reducing risks. Text Blocks simplify the creation of multi-line string literals, improving code readability. These features enhance developer productivity and provide better support for modern application development in the Java ecosystem.
Java SE 16 Features
Java SE 16, released in 2021, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 16.
1. Pattern Matching for instanceof (Standard Feature)
Java SE 16 enhanced the Pattern Matching for instanceof feature introduced in Java SE 14 and made it a standard feature. It allows developers to use pattern matching with instanceof to simplify common coding patterns, such as conditional casting and extracting values from objects. Here's an example:
if (shape instanceof Circle circle) {
double radius = circle.getRadius();
// Perform circle-specific operations
}
2. Records (Standard Feature)
Java SE 16 enhanced the Records feature introduced in Java SE 14 and made it a standard feature. Records provide a concise way to declare classes that are primarily used for holding data. They automatically generate common methods such as constructors, accessors, and equals/hashCode methods based on the defined fields. Here's an example:
public record Person(String name, int age) { }
Person person = new Person("John Doe", 30);
String name = person.name();
int age = person.age();
Conclusion
Java SE 16 brought valuable enhancements to existing features such as Pattern Matching for instanceof (Standard Feature) and Records (Standard Feature). Pattern Matching for instanceof simplifies conditional casting and value extraction from objects. Records provide a concise way to declare data-holding classes with automatically generated methods. These features enhance developer productivity and provide better support for modern application development in the Java ecosystem.
Java SE 17 Features
Java SE 17, released in 2021, introduced several new features and enhancements to the Java programming language. These features aimed to improve developer productivity, enhance performance, and provide better support for modern application development. Let's explore two notable features of Java SE 17.
1. Sealed Classes (Preview Feature)
Java SE 17 introduced the preview feature of Sealed Classes, which allows developers to restrict the subclasses that can extend a class or implement an interface. This enhances encapsulation and provides more control over class hierarchies. Here's an example:
public abstract sealed class Shape permits Circle, Rectangle {
// Class definition
}
public final class Circle extends Shape {
// Class definition
}
public final class Rectangle extends Shape {
// Class definition
}
2. Pattern Matching for Switch (Standard Feature)
Java SE 17 introduced the Pattern Matching for Switch feature as a standard feature. It allows developers to use patterns in switch statements, simplifying the matching and extraction of values from cases. Here's an example:
public String getMessage(ErrorCode code) {
return switch (code) {
case OK -> "Operation successful";
case WARNING, INFO -> "Warning or informational message";
case ERROR -> "An error occurred";
};
}
Conclusion
Java SE 17 brought valuable enhancements with features like Sealed Classes (Preview Feature) and Pattern Matching for Switch (Standard Feature). Sealed Classes provide better control over class hierarchies by restricting the allowed subclasses. Pattern Matching for Switch simplifies the matching and extraction of values in switch statements. These features improve developer productivity, enhance code readability, and offer more expressive capabilities to Java developers.
Java SE 18 Features
1. UTF-8 by Default
Java 18 changes the default charset to UTF-8, simplifying character encoding and aligning with the widely used standard.
2. Simple Web Server
A minimalistic web server is introduced, allowing developers to serve static files easily for prototyping and testing purposes.
3. Code Snippets in Java API Documentation
The API documentation includes small code snippets that developers can directly use in their applications, providing practical examples for using Java features.
4. Vector API
Java 18 introduces the Vector API, which enables performing vector computations efficiently. This API is helpful for numeric computations, scientific calculations, and machine learning algorithms.
5. Internet-Address Resolution SPI
The new InetAddress API provides a service-provider interface (SPI) for hostname and address resolution. It allows using resolvers other than the built-in resolver, providing more flexibility in resolving hostnames to IP addresses and vice versa.
6. Foreign Function and Memory API
Java SE 18 includes libraries that enable interacting with non-JVM systems, such as JDBC drivers for database connections and sockets for network communication.
7. Pattern Matching Improvements
Pattern matching simplifies matching objects against patterns, improving readability and code safety. It can be used in switch statements to handle different cases based on object types.
8. Deprecated Finalization for Removal
The finalize method, used for object cleanup, has been deprecated and will be warned in Java SE 18. This signals its potential removal in future releases, as it has limitations and is not recommended for normal program execution.
Java SE 18 focuses on enhancing developer experience, improving performance, and providing new capabilities to meet modern programming needs. These updates aim to make Java more accessible and intuitive for developers of all skill levels.
Java Development Kit 19 Features
Java Development Kit (JDK) 19, a non-LTS (long-term support) release of standard Java, has arrived today as a production release. It follows the six-month release cadence and is the tenth six-month release.
The JDK 19 features include:
- Structured Concurrency (Incubator Phase): Simplifies multithreaded programming through a structured concurrency API, treating multiple tasks as a single unit of work, improving error handling and cancellation.
- Preview of Record Patterns: Allows deconstructing record values and nesting record patterns and type patterns for declarative and composable data navigation and processing.
- Preview of Foreign Function and Memory API: Enables Java programs to interoperate with code and data outside the Java runtime, invoking foreign functions and accessing foreign memory safely and efficiently.
- Support for Linux/RISC-V Instruction Set Architecture (ISA): Adds support for the open-source Linux/RISC-V ISA, specifically the RV64GV configuration, allowing Java to leverage this hardware instruction set.
- Third Preview of Pattern Matching for Switch Expressions and Statements: Extends pattern matching to switch expressions, enabling concise and safe data-oriented queries with refinements to enhance expressiveness and compatibility.
- Fourth Incubation of Vector API: Enables writing complex vector algorithms in Java, achieving performance gains through optimal vector instructions on supported CPU architectures.
- Improvements to the Vector API: Enhancements include load and store operations, cross-lane vector operations, and expanded bitwise integral lane-wise operations.
JDK 19 is available for download from oracle.com. It is a short-term release with six months of top-level Premier support.
Java continues to evolve with regular releases, providing developers with new capabilities, improved performance, and enhanced developer experience.
Java Development Kit (JDK) 20 Features
Java Development Kit (JDK) 20 is now available as a production release from Oracle. This latest upgrade of standard Java introduces several new capabilities in an incubation or preview stage.
The JDK 20 features include:
- Vector API: A proposal to express vector computations that compile as optimal vector instructions on supported CPU architectures, achieving superior performance. This API has been incubated in previous JDK versions.
- Virtual Threads (Second Preview): Lightweight threads that simplify writing and scaling high-throughput concurrent applications, with minor changes since the first preview in JDK 19.
- Structured Concurrency: An API to simplify multithreaded programming by treating multiple tasks as a single unit of work, improving error handling and cancellation. This feature is being reincubated with minor changes since JDK 19.
- Scoped Values: An API in incubator stage to share immutable data within and across threads, offering a safer alternative to thread-local variables.
- Record Patterns (Second Preview): Enhances Java with patterns to deconstruct record values, enabling powerful and composable data navigation and processing.
- Foreign Function and Memory API: Enables Java programs to interoperate with code and data outside the Java runtime, avoiding the drawbacks of the Java Native Interface (JNI). This API has been incubated and refined in previous JDK versions.
- Pattern Matching for Switch Statements and Expressions: Allows concise and safe expression of complex data-oriented queries, with refinements based on experience and feedback from previous previews.
JDK 20 is a short-term release with six months of support. JDK 21, scheduled for release in September, will be a long-term support (LTS) release with extended support.
Java developers can download JDK 20 from oracle.com to explore and try out these new features. Oracle encourages users to provide feedback and help shape the future of Java.
The features in JDK 20 are derived from Java research projects including Amber, Panama, and Loom, focusing on productivity, interconnecting with native code, and incubating new JVM features and APIs.
Java Development Kit (JDK) 21 Features
Java Development Kit (JDK) 21, the next long-term support release of Oracle’s standard Java implementation, is scheduled for September. The release is set to include 13 proposed features, with two additional features recently added.
The latest proposals consist of a key encapsulation mechanism (KEM) API and the deprecation of the 32-bit x86 Windows port. Other additions this month include a generational Shenandoah garbage collector, unnamed classes and instance main methods, and unnamed patterns and variables.
These proposals join eight features proposed in earlier months, including
- A generational ZGC (Z Garbage Collector)
- Record Patterns
- Pattern matching for switch expressions and statements
- A vector API
- Sequenced collections
- virtual threads
- A preview of string templates and
- A third preview of a foreign function and memory API
- Easy Upgrade with Docker: If you're utilizing Docker, upgrading to Java 17 becomes a seamless process, allowing you to leverage the latest features effortlessly.
- Long-Term Support (LTS): Java 17 being an LTS release ensures that it will continue to receive updates and support even as newer versions are introduced in the future.
- Cool New Features: Java 17 introduces exciting new features that can enhance your application's functionality and performance. It's worth exploring these features and considering their potential benefits.
Additionally, JDK 21 will change how network names are assigned to network interfaces on Windows.
JDK 21 will be an LTS release, receiving five years of Premier support and extended support until September 2031. The current LTS release is JDK 17, while non-LTS releases receive only six months of premier support and no extended support.
Some potential features that could be added to JDK 21 include scoped values for sharing immutable data within and across threads, graduating structured concurrency to preview status, preparing to disallow the dynamic loading of agents, and introducing an experimental compact object headers capability to reduce heap size in the JVM.
The release schedule for JDK 21 includes rampdown phases in June and July, followed by release candidates in August and general availability on September 19.
Which version is stable and mostly used in industry ?
Java 11 is a long-term support (LTS) release, which means it receives regular updates and support for an extended period. Many organizations and projects have transitioned to Java 11 and continue to use it for their production systems.
Update (June 23, 2022): Java 17 - The Latest Version with Long-Term Support (LTS)
Java 17 has emerged as the newest version of Java, providing long-term support (LTS). While many applications still rely on Java 8 or Java 11, there are several compelling reasons to consider upgrading to Java 17:
However, it's important to note that even in 2022, many applications are still running on Java 8 or Java 11, and that is perfectly normal. These versions continue to be widely used and supported.
In the current landscape, Java 8+ is the preferred choice for the majority of applications. With Java 17 joining the LTS lineup, you now have three LTS versions to choose from - Java 8, Java 11, and Java 17.
Update (February 15, 2021): Java 11 - The Latest LTS Version with Exciting New Features
As of February 15, 2021, Java 11 remains the most recent version that offers long-term support (LTS). It ensures stability and receives regular updates, making it a reliable choice for many applications. On the other hand, Java 15 introduces promising new features that developers can explore and experiment with.