Java 17 introduced key features like sealed classes, pattern matching for switch (preview), removal of the Applet API, a new macOS rendering pipeline, stronger encapsulation of JDK internals by default, and the incubator Foreign Function & Memory API; beyond Java 17, versions 18 to 22 added the simple web server (incubator), virtual threads (preview across Java 19, 21), record and array patterns (preview in Java 21), unnamed variables and patterns (preview in Java 21), scoped values (preview in Java 21), and string templates (preview in Java 22); looking ahead, Project Loom, Panama, Valhalla, and Amber are driving innovation in concurrency, native interoperability, performance, and developer productivity, with Java 21 being the next LTS after Java 17, marking a faster evolution of the language toward being simpler, more expressive, and scalable.

Java 17, released in September 2021, marked a major milestone as the next Long-Term Support (LTS) version after Java 11. Since then, the Java ecosystem has continued evolving with regular feature releases (Java 18 through 22 as of 2024), setting the stage for future innovation. Here’s what’s new in Java 17 and what’s shaping up beyond it.

Key Features in Java 17

Java 17 brought several important changes, many of which were incubator or preview features in earlier versions that became stable.

1. Sealed Classes (Stable)

Sealed classes let you restrict which classes can extend or implement a given class or interface. This improves encapsulation and makes domain models more predictable.

public sealed interface Shape permits Circle, Rectangle, Triangle {}

public final class Circle implements Shape { }
public final class Rectangle implements Shape { }
public non-sealed class Triangle implements Shape { } // allows further extension

This is especially useful in pattern matching and modeling algebraic data types.

2. Pattern Matching for switch (Preview)

Though not yet stable in Java 17, this preview feature allows switch to deconstruct objects based on their type:

String result = switch (obj) {
    case Integer i -> "Integer: "   i;
    case String s -> "String: "   s;
    case null -> "null";
    default -> "Unknown";
};

It reduces boilerplate and improves readability.

3. Removal of Applet API

The long-deprecated Applet API was removed. Applets have been obsolete for years due to security and browser support issues.

4. New macOS Rendering Pipeline

Java 17 introduced a new Apple Silicon-friendly rendering pipeline for macOS, improving graphics performance on M1 and later chips.

5. Strongly Encapsulate JDK Internals by Default

--illegal-access=deny became the default. This enforces stronger encapsulation of internal JDK APIs (like sun.misc.Unsafe), pushing developers to use proper alternatives.

6. Foreign Function & Memory API (Incubator)

Introduced as an incubator API, this aims to replace JNI with a safer, more efficient way to interact with native code and memory.

What’s New Beyond Java 17 (Java 18 to 22)

Since Java 17, the six-month release cycle has accelerated innovation. Here are notable features from recent versions.

Java 18: Simple Web Server (Incubator)

A lightweight HTTP server included in the JDK, useful for prototyping and testing:

jwebserver -p 8080

No external dependencies needed—great for quick file sharing or REST endpoint testing.

Java 19 & 21: Virtual Threads (Preview → Second Preview → Third Preview)

Part of Project Loom, virtual threads are lightweight threads managed by the JVM, not the OS. They make it easy to scale high-throughput concurrent applications:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(1000);
            return i;
        });
    });
} // Auto-shutdown

This can dramatically simplify concurrent code—no need for complex thread pools or reactive programming in many cases.

Java 21: Record Patterns and Array Patterns (Preview)

Enhances pattern matching to deconstruct records and arrays directly in switch or if conditions:

if (obj instanceof Point(int x, int y) && x > 0) {
    System.out.println("Positive point: "   y);
}

Reduces nested destructuring and improves code clarity.

Java 21: Unnamed Variables and Patterns (Preview)

Allows using _ to ignore unused variables in patterns:

if (obj instanceof Point(int x, _) && x > 0) { ... }

Cleans up code when you only care about certain components.

Java 21: Scoped Values (Preview)

Scoped values safely share data across threads—especially useful in virtual thread environments where thread locals can be inefficient.

ScopedValue.define("user.id", 123);
ScopedValue<String> USER_ID = ScopedValue.newInstance();

// In a virtual thread
String id = USER_ID.get(); // safely inherited

Great for context propagation (e.g., request-scoped data in web apps).

Java 22: String Templates (Preview)

Introduces STR processor for inline expressions in strings:

String name = "Alice";
int age = 30;
String info = STR."Hello, \{name}! You are \{age} years old.";

Safer and cleaner than String.format() or concatenation.

Also supports custom processors (like FMT for formatting with localization).

Looking Ahead: What’s in the Pipeline?

Several major initiatives are shaping Java’s future:

• Project Loom: Virtual threads and structured concurrency will likely be standard in Java 23 or 24, transforming how we write concurrent applications.
• Project Panama: Aims to improve JVM interoperability with native code and data, building on Foreign Function & Memory API.
• Project Valhalla: Exploring value types and generic specialization—could dramatically improve performance for data-heavy applications.
• Project Amber: Focuses on productivity features like pattern matching, records, and sealed types.

Summary

Java 17 solidified modern Java with sealed classes, better encapsulation, and early previews of Loom and Panama. Beyond 17, the language is evolving fast—virtual threads, pattern matching, string templates, and scoped values are making Java more expressive, scalable, and developer-friendly.

With LTS versions expected every two years (Java 21 is the next LTS after 17), now is a great time to upgrade and explore these features in production.

Basically, Java isn’t standing still—it’s becoming simpler, faster, and more powerful, one release at a time.

The above is the detailed content of What's New in Java 17 and Beyond. For more information, please follow other related articles on the PHP Chinese website!