What are the new features in Java 17 (LTS)?

Java 17 is an LTS version. It introduces sealed classes, pattern matching switches, record classes, improves random number generation, strongly encapsulates JDK internals, deprecates Applet APIs, adds foreign functions and memory APIs, and supports macOS/AArch64 to improve performance, security and cross-platform capabilities.

Java 17, released in September 2021, is a long-term support (LTS) version that brings several important updates, performance improvements, and language enhancements. It builds on the foundation laid by Java 11 (the previous LTS) and includes features aimed at improving developer productivity, security, and performance.

Sealed Classes (JEP 409)

Sealed classes allow you to restrict which other classes or interfaces can extend or implement them. This gives better control over inheritance hierarchies, making domain models more robust and predictable.

You use the sealed modifier on a class or interface, then specify permitted subclasses using the permits clause.

sealed interface Shape permits Circle, Rectangle, Triangle { }
<p>final class Circle implements Shape { }
final class Rectangle implements Shape { }
non-sealed class Triangle implements Shape { }</p>

This feature works well with pattern matching, enabling exhaustiveness checks in switch expressions.

Pattern Matching for switch (Preview - JEP 406)

Java 17 introduces an enhanced switch expression that supports pattern matching. You can now test values ​​against patterns and deconstruct them directly within switch cases, reducing boilerplate code.

For example:

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

This makes code more readable and safer by eliminating manual casting and instanceof checks.

Record Classes (Standardized - JEP 405)

Records were introduced as a preview feature earlier and are now finalized in Java 17. They provide a compact syntax for declaring classes that are meant to be transparent carriers of data.

A record automatically generates constructors, accessors, equals(), hashCode(), and toString() methods.

record Person(String name, int age) { }

This reduces verbosity when modeling immutable data, especially useful in DTOs and APIs.

Improved Random Number Generation (JEP 356)

Java 17 enhances the Random API with new interface RandomGenerator and multiple implementations like LXM, Xoshiro, etc., offering better statistical independence and performance.

The RandomGeneratorFactory allows selection of algorithms based on needs:

RandomGenerator generator = 
    RandomGeneratorFactory.of("L64X128MixRandom").create();

It simplifies migration and improves flexibility for applications needing high-quality randomness.

Strongly Encapsulate JDK Internals (JEP 403)

By default, Java 17 strongly encapsulates all internal elements of the JDK. This means you can no longer access internal APIs (like sun.misc.Unsafe) via reflection without explicit flags.

This improves security and maintainability by encouraging use of standard APIs and pushing developers away from unsupported APIs.

If needed, you can still open modules temporarily using command-line flags like --add-opens , but it's recommended to refactor code to avoid reliance on internal packages.

Deprecate Applet API for Removal

The Applet API has been deprecated and marked for removal. Since applets have been obsolete for years due to security issues and lack of browser support, this reflects modern web development practices.

Developers should migrate any remaining applet-based applications to alternative technologies like web frameworks or desktop GUI tools (eg, JavaFX).

Foreign Function & Memory API (Incubator - JEP 412)

This new API enables Java programs to interoperate with native code and memory more efficiently than JNI. It provides safe and efficient ways to call C libraries and manage off-heap memory.

Key components include:

• MemorySegment : Represents off-heap memory regions.
• VarHandle : For reading/writing memory segments.
• Linker : To bind Java method handles to native functions.

This paves the way for future replacement of JNI with a more modern, type-safe approach.

Enhanced Pseudo-Random Number Generators

In addition to general RNG improvements, new random generators such as DoublesStream , SplittableRandom , and support for deterministic streams improve testing and simulation scenarios.

These help in parallel computing where reproducible sequences are required across threads.

Porting to macOS/AArch64 (JEP 391)

Java 17 adds native support for Apple's M1 chips (AArch64 architecture), ensuring optimal performance on newer Macs. This allows Java applications to run natively without Rosetta 2 translation.

It also aligns Oracle JDK builds across platforms, including ARM64 versions for Linux and Windows.

Basically, Java 17 consolidates many preview features into stable APIs while enhancing performance, security, and cross-platform support. Upgrading from Java 11 is highly recommended for long-term projects due to its LTS status and modern tooling improvements.

The above is the detailed content of What are the new features in Java 17 (LTS)?. For more information, please follow other related articles on the PHP Chinese website!