What’s New in Java 16? Key Features and Improvements Explained

Java 16 has been officially released.

Main Features

Vector API (incubating)

Improves Java’s performance for CPU vector calculations, supporting large‑scale tensor computation and enhancing AI capabilities.

New C++ Features

Allows use of new C++14 language features within the JDK source code.

Migration from Mercurial to Git

Java now uses Git for source code management, aligning with the dominant version‑control system.

Migration to GitHub

The OpenJDK codebase is now hosted on GitHub.

ZGC Garbage Collector

A concurrent thread‑stack processing garbage collector.

Unix‑Domain Socket Channels

Support for ServerSocketChannel and SocketChannel over Unix‑domain sockets.

Alpine Linux Port

Ports the JDK to Alpine Linux on x64 and AArch64, targeting distributions that use the musl C library.

Elastic Metaspace

Significant improvements to HotSpot’s metaspace handling, reducing memory usage and enabling faster reclamation of unused memory.

Windows/AArch64 Port

Ports the JDK to Windows on AArch64 platforms.

Foreign Linker API (incubating)

Introduces an API that provides statically‑typed pure‑Java access to native code, simplifying binding to native libraries together with the Foreign‑Memory API (JEP 393).

Warnings for Value‑Based Classes

Marks primitive wrapper classes as value‑based and deprecates their constructors, issuing warnings for incorrect synchronization attempts on such classes.

Packaging Tool

Provides the jpackage tool for packaging standalone Java applications.

Supports native packaging formats such as msi and exe on Windows, pkg and dmg on macOS, and deb and rpm on Linux.

Allows specifying runtime parameters at packaging time.

Can be invoked from the command line or programmatically via the ToolProvider API.

Foreign‑Memory Access API (third incubating)

Introduces an API that enables safe and efficient access to off‑heap memory from Java programs.

Pattern Matching for instanceof

Before:

// first check type
if (obj instanceof String) {
    // then cast
    String s = (String) obj;
    // now can use
}

With pattern matching:

if (obj instanceof String s) {
    // can use s directly
} else {
    // cannot use directly
}

Records

Traditional class definition:

public class Range {
    private final int min;
    private final int max;
    public Range(int min, int max) {
        this.min = min;
        this.max = max;
    }
    public int getMin() { return min; }
    public int getMax() { return max; }
    @Override public boolean equals(Object o) { /* ... */ }
    @Override public int hashCode() { return Objects.hash(min, max); }
    @Override public String toString() { return "Range{" + "min=" + min + ", max=" + max + '}'; }
}

Now can be simplified to:

public record Range(int min, int max) {}

See earlier article on Java 14 Records (JEP 359) for details.

Strict Encapsulation by Default

Improves JDK security and maintainability; not directly relevant to ordinary developers.

Sealed Classes

Sealed classes cannot be subclassed, preventing malicious inheritance.

Oracle also thanked the organizations and individuals that contributed to JDK 16, including ARM, SAP, Red Hat, Tencent, Ampere Computing, Bellsoft, DataDog, Microdoc, and independent developers.