What Changed from Java 8 to Java 25

01The timeline at a glance

Java 8 came in March 2014 and Java 9 in September 2017. Since then: March and September every year. The LTS releases are the ones most teams adopt, and the ones this map treats as milestones.

Check which JDK you are running with java -version. The first number after version is the feature release. (Up to Java 8 the version string started with 1., like 1.8.0_231; from Java 9 it is just 9, 11.0.2, 21.0.9.)

02Java 8 (March 2014, LTS): the functional revolution

Language: lambda expressions and method references (Topic 10.1, 10.3); functional interfaces like Function and Predicate in java.util.function; default and static methods in interfaces (Topic 5.8); type annotations and repeatable annotations.

Library: the Stream API (Topic 10.4); Optional (Topic 10.7); the new date and time API java.time (Topic 12.5); CompletableFuture (Topic 13.7); String.join; java.util.Base64; StampedLock; Arrays.parallelSort; new Map methods such as getOrDefault, computeIfAbsent, merge and forEach.

JVM: the permanent generation (PermGen) was replaced by Metaspace in native memory, ending most OutOfMemoryError: PermGen space errors. The Nashorn JavaScript engine replaced Rhino.

03Java 9 (September 2017) and Java 10 (March 2018)

Java 9. The module system (JPMS, Project Jigsaw, Topic 15.3): the JDK itself was split into modules like java.base. JShell, the interactive shell (Topic 0.6). Collection factory methods List.of, Set.of, Map.of (Topic 9.11). Private methods in interfaces. Try-with-resources on an existing effectively-final variable. The diamond <> with anonymous classes. Stream additions takeWhile, dropWhile, ofNullable and a three-argument iterate; Optional.ifPresentOrElse, or and stream. G1 became the default garbage collector. Compact strings store Latin-1 text in one byte per character. Also StackWalker, VarHandle, the Flow reactive-streams interfaces, multi-release JARs, and _ became a keyword.

Java 10. Local variable type inference with **var** (Topic 1.11). List.copyOf, Set.copyOf, Map.copyOf; Collectors.toUnmodifiableList and friends; Optional.orElseThrow() with no arguments. Application class-data sharing, and the JVM began respecting container (Docker) CPU and memory limits. Java 10 was the first six-month release.

04Java 11 (September 2018, LTS): the modern baseline

Language: var allowed in lambda parameters, so they can carry annotations: (@NonNull var x) -> .... Running a single source file directly: java Hello.java (JEP 330).

Library: the standard HTTP client java.net.http.HttpClient (HTTP/1.1 and HTTP/2, sync and async). String.isBlank, strip, stripLeading, stripTrailing, lines and repeat (Topic 6.4). Files.readString and Files.writeString. Optional.isEmpty. Predicate.not. Collection.toArray(IntFunction). TLS 1.3.

JVM and tools: Flight Recorder (JFR) open-sourced into OpenJDK (Topic 14.5); the no-op Epsilon GC; ZGC as an experimental low-pause collector.

Removed: the Java EE and CORBA modules (JEP 320): javax.xml.bind (JAXB), javax.xml.ws (JAX-WS), javax.activation, javax.annotation and others now come from separate libraries. JavaFX is no longer bundled with Oracle's JDK. Nashorn was deprecated.

05Java 12 to 16: less boilerplate

Java 12 (2019): String.indent and String.transform; Collectors.teeing; Files.mismatch; CompactNumberFormat; the experimental Shenandoah GC; switch expressions as a preview.

Java 13 (2019): text blocks and yield in switch expressions as previews; ZGC can return unused memory to the operating system; dynamic class-data-sharing archives.

Java 14 (2020): switch expressions become standard (Topic 2.4). Helpful NullPointerExceptions that name the null variable (Topic 7.8). Records and pattern matching for instanceof as previews. The CMS garbage collector was removed; JFR event streaming added.

Java 15 (2020): text blocks become standard (Topic 6.5), along with String.formatted and stripIndent. ZGC and Shenandoah become production features. Hidden classes for frameworks. The EdDSA signature algorithm. Nashorn removed. Biased locking deprecated. Sealed classes as a preview.

Java 16 (2021): records (Topic 4.9) and **pattern matching for instanceof** (Topic 11.1) become standard. Stream.toList(). The jpackage tool for native installers. Unix-domain socket channels. JDK internals strongly encapsulated by default (--illegal-access=deny). OpenJDK moved to Git and GitHub.

06Java 17 (September 2021, LTS): sealed types and locked internals

Language: sealed classes and interfaces become standard (Topic 5.11). Floating-point arithmetic is always strict again, so strictfp is redundant. Pattern matching for switch appears as a preview.

Library: enhanced pseudo-random number generators (RandomGenerator interface and new algorithms); HexFormat; context-specific deserialization filters.

Restrictions and removals: JDK internals are strongly encapsulated with no command-line escape hatch: --illegal-access is gone, and reflective access to internal classes needs explicit --add-opens. The Security Manager and the Applet API are deprecated for removal. RMI activation and the experimental AOT/Graal JIT compiler were removed. A macOS/AArch64 (Apple silicon) port was added.

07Java 18 to 20: UTF-8 everywhere and previews of the future

Java 18 (2022): UTF-8 by default (JEP 400): reading and writing files without an explicit charset now uses UTF-8 on every operating system. A minimal static web server, jwebserver. @snippet for code in Javadoc. Core reflection reimplemented on method handles. Finalization deprecated for removal.

Java 19 (2022): previews of virtual threads, record patterns and the foreign function and memory API; structured concurrency as an incubator; a Linux/RISC-V port.

Java 20 (2023): further previews of the same features, plus scoped values as an incubator. Nothing major became standard in 19 or 20, but these previews shaped Java 21.

08Java 21 (September 2023, LTS): virtual threads and data-oriented Java

Language: record patterns (Topic 11.3) and **pattern matching for switch** (Topic 11.2) become standard.

Library: virtual threads (JEP 444, Topic 13.10): millions of cheap threads for blocking code. Sequenced collections (JEP 431, Topic 9.12): getFirst, getLast, addFirst, reversed on lists, deques, LinkedHashSet, LinkedHashMap and sorted collections. The key encapsulation mechanism (KEM) API. Small additions such as Math.clamp and StringBuilder.repeat.

JVM: generational ZGC (JEP 439). Warnings when an agent is loaded dynamically into a running JVM. The 32-bit Windows x86 port deprecated for removal.

Previews in 21: unnamed patterns and variables, unnamed classes and instance main methods, string templates (later withdrawn and never released as a standard feature), structured concurrency, and scoped values.

09Java 22 to 25: finishing the picture

Java 22 (2024): unnamed variables and patterns _ (Topic 11.4). The foreign function and memory API (java.lang.foreign, JEP 454) becomes standard, a safer replacement for JNI. Launching multi-file source programs with java Main.java. Region pinning for G1. Previews: statements before super(...), stream gatherers, the class-file API.

Java 23 (2024): Markdown documentation comments (///). ZGC uses generational mode by default. The memory-access methods of sun.misc.Unsafe deprecated for removal. Previews: primitive types in patterns, module import declarations, and more rounds of earlier previews.

Java 24 (2025): stream gatherers (Stream.gather, Gatherers.windowFixed and others, JEP 485) and the class-file API (JEP 484) become standard. Virtual threads no longer pin their carrier thread inside synchronized (JEP 491). Ahead-of-time class loading and linking (JEP 483) for faster start-up. Post-quantum ML-KEM and ML-DSA algorithms. The Security Manager is permanently disabled (JEP 486). Non-generational ZGC removed. Compact object headers as an experimental option.

Java 25 (September 2025, LTS): **compact source files and instance main methods (Topic 11.5). Module import declarations** (import module java.base;). Flexible constructor bodies: statements before super(...) or this(...) as long as they don't use the object being built. Scoped values (Topic 13.11). The key derivation function API. Compact object headers and generational Shenandoah become product features. AOT command-line ergonomics and method profiling for faster warm-up. New JFR features (CPU-time profiling as experimental, method timing and tracing). The 32-bit x86 port removed. Still in preview: structured concurrency, primitive types in patterns, stable values, PEM encodings; the Vector API is still incubating.

// Java 25: flexible constructor bodies (JEP 513)
class Account extends Base {
    Account(String id) {
        if (id.isBlank()) throw new IllegalArgumentException("blank id"); // before super(...)
        super(id.strip());
    }
}

// Java 24: stream gatherers (JEP 485)
List<List<Integer>> windows = Stream.of(1, 2, 3, 4, 5)
        .gather(Gatherers.windowFixed(2))
        .toList();                       // [[1, 2], [3, 4], [5]]