Java Version History: JDK 1.0 to Java 27

Java 28

In developmentMarch 2027 (planned)

Not released yet. JDK 28 is scheduled for March 2027 and is the first release to preview Project Valhalla’s value objects. Its JEP list can still change; this is the state on October 24, 2026.

Featured

Value objects (preview) — Project Valhalla’s first preview: value classes and records have no identity, so the JVM can flatten them in memory and == compares their fields.
Simple JSON API (incubator) — A small built-in API to parse, navigate and generate JSON without a third-party library.
Structured concurrency becomes final — After seven previews, StructuredTaskScope treats a group of concurrent subtasks as one unit of work, with clean cancellation and error handling.
PEM encodings become final — Read and write keys and certificates in the PEM text format with a standard API, after three previews.
Shenandoah: generational mode by default — Shenandoah GC runs in generational mode unless you choose otherwise.
macOS on Intel deprecated — The macOS/x64 port is deprecated for removal. Apple-silicon Macs are not affected.

All changes in Java 28 (9)

Source: OpenJDK JDK 28 project ↗

Java 27

FeatureSeptember 2026

The latest release. Mostly runtime and security work: G1 everywhere, compact object headers on by default and post-quantum TLS.

Featured

G1 is the default GC everywhere — Even on small machines, the JVM now picks G1 instead of the Serial GC.
Compact object headers by default — Object headers shrink to 8 bytes on 64-bit platforms, reducing heap usage with no code change.
Post-quantum hybrid key exchange for TLS 1.3 — TLS 1.3 can combine classic key exchange with ML-KEM, protecting today’s traffic against future quantum attacks.
JFR in-process data redaction — Flight Recorder can remove sensitive values from recordings before they are written.

All changes in Java 27 (9)

Source: OpenJDK JDK 27 project ↗

Java 26

FeatureMarch 2026

HTTP/3, ahead-of-time caching for any GC, and the first step toward making final fields truly final.

Featured

HTTP/3 in the HTTP Client — java.net.http.HttpClient can use HTTP/3 (QUIC) when you opt in.
Ahead-of-time object caching with any GC — Project Leyden’s AOT cache now works with every garbage collector, including ZGC.
Prepare to make final mean final — Changing final fields through deep reflection now prints warnings; a future release will block it.
Applet API removed — java.applet and related classes, deprecated since Java 9, are gone.

All changes in Java 26 (10)

Source: OpenJDK JDK 26 project ↗

Java 25

LTSSeptember 2025

The current LTS release. Finalizes many features previewed since Java 21: compact source files, flexible constructors, module imports and scoped values.

Featured

Compact source files and instance main methods — A complete program can be void main() { IO.println("Hello"); }, with no class declaration and no static.
Flexible constructor bodies — Validate arguments and compute values before calling super(...) or this(...).
Module import declarations — import module java.base; imports every package a module exports.
Scoped values — A safer, faster alternative to ThreadLocal for sharing immutable data with callees and child threads.
Compact object headers (opt-in) — Enable with -XX:+UseCompactObjectHeaders to reduce memory use. It became the default in Java 27.
Faster startup with AOT profiling — Simpler commands to create an ahead-of-time cache, which now also stores method profiles for quicker warmup.

All changes in Java 25 (18)

Source: OpenJDK JDK 25 project ↗

Java 24

FeatureMarch 2025

A big release with 24 JEPs, including Stream Gatherers, the Class-File API, virtual threads without pinning and the first post-quantum algorithms.

Featured

Stream Gatherers — Stream.gather(...) lets you write your own intermediate operations, such as sliding windows.
Virtual threads no longer pin in synchronized — Blocking inside synchronized no longer ties a virtual thread to its carrier thread.
Class-File API — A standard API to parse, generate and transform .class files.
Post-quantum cryptography — ML-KEM and ML-DSA, the NIST-standardized quantum-resistant algorithms for key encapsulation and signatures.
Ahead-of-time class loading & linking — The first Project Leyden feature: record a training run, then start faster from an AOT cache.
Security Manager permanently disabled — The Security Manager can no longer be enabled.

All changes in Java 24 (24)

Source: OpenJDK JDK 24 project ↗

Java 23

FeatureSeptember 2024

Markdown in Javadoc, generational ZGC by default and more previews. String Templates, previewed in 21 and 22, were withdrawn.

Featured

Markdown documentation comments — Write Javadoc in Markdown using /// comments instead of HTML.
Generational ZGC by default — -XX:+UseZGC now selects the generational mode.
sun.misc.Unsafe memory access deprecated — Unsafe’s memory-access methods are deprecated for removal; use VarHandle or the FFM API.
Primitive types in patterns (preview) — Patterns, instanceof and switch start to work with int, long, double and other primitives.

All changes in Java 23 (13)

Source: OpenJDK JDK 23 project ↗

Java 22

FeatureMarch 2024

The Foreign Function & Memory API and unnamed variables become final; multi-file programs run without a build tool.

Featured

Foreign Function & Memory API — Call native libraries and manage off-heap memory from pure Java, a safer replacement for JNI.
Unnamed variables & patterns — Use _ for variables and pattern parts you don’t need, for example catch (Exception _).
Launch multi-file source-code programs — java Main.java compiles and runs a program spread across several source files.
Region pinning for G1 — G1 keeps collecting during JNI critical regions instead of pausing garbage collection.

All changes in Java 22 (12)

Source: OpenJDK JDK 22 project ↗

Java 21

LTSSeptember 2023

A landmark LTS: virtual threads, record patterns, pattern matching for switch and sequenced collections are all final.

Featured

Virtual threads — Lightweight threads managed by the JVM. Write simple blocking code and still run huge numbers of concurrent tasks.
Pattern matching for switch — switch can test types and deconstruct values, with exhaustiveness checks for sealed types.
Record patterns — Deconstruct records directly: if (obj instanceof Point(int x, int y)).
Sequenced collections — New interfaces add getFirst(), getLast() and reversed() to lists, deques and ordered sets and maps.
Generational ZGC — ZGC can separate young and old objects, lowering CPU and memory overhead.

All changes in Java 21 (15)

Source: OpenJDK JDK 21 project ↗

Java 20

FeatureMarch 2023

A preview-only release that refined the features finalized in Java 21.

Featured

Scoped values (incubator) — The first look at scoped values, an immutable alternative to thread-local variables.
Virtual threads (second preview) — Further refinement before virtual threads became final in Java 21.
Record patterns (second preview) — Adds type inference for generic record patterns.

All changes in Java 20 (7)

Source: OpenJDK JDK 20 project ↗

Java 19

FeatureSeptember 2022

Virtual threads and structured concurrency appear for the first time, as preview and incubator features.

Featured

Virtual threads (preview) — Project Loom’s headline feature ships for the first time, behind --enable-preview.
Structured concurrency (incubator) — Treat related tasks running in different threads as one unit of work.
Record patterns (preview) — The first preview of deconstructing records in patterns.
Linux/RISC-V port — The JDK officially runs on 64-bit RISC-V Linux.

All changes in Java 19 (7)

Source: OpenJDK JDK 19 project ↗

Java 18

FeatureMarch 2022

UTF-8 becomes the default charset on every platform, and the JDK gains a small built-in web server.

Featured

UTF-8 by default — APIs that use the default charset now use UTF-8 on every OS, ending many platform-specific encoding bugs.
Simple web server — jwebserver serves static files from a directory, handy for testing and teaching.
Code snippets in Javadoc — The @snippet tag shows validated example code in API documentation.
Finalization deprecated for removal — finalize() is on its way out; use try-with-resources or Cleaner instead.

All changes in Java 18 (9)

Source: OpenJDK JDK 18 project ↗

Java 17

LTSSeptember 2021

An LTS that finalizes sealed classes and strongly encapsulates JDK internals. Oracle introduced its free NFTC license with this release.

Featured

Sealed classes — Control which classes may extend a type: sealed interface Shape permits Circle, Square.
Strongly encapsulated JDK internals — Internal JDK APIs can no longer be opened with a single launcher flag; use --add-opens for specific packages.
Enhanced pseudo-random number generators — New RandomGenerator interfaces and algorithms such as LXM.
macOS/AArch64 port — Native support for Apple-silicon Macs.
Pattern matching for switch (preview) — The first preview of type patterns in switch.

All changes in Java 17 (14)

Source: OpenJDK JDK 17 project ↗

Java 16

FeatureMarch 2021

Records and pattern matching for instanceof become final. OpenJDK moved to Git and GitHub.

Featured

Records — record Point(int x, int y) {} declares an immutable data class with constructor, accessors, equals, hashCode and toString.
Pattern matching for instanceof — if (obj instanceof String s) tests and casts in one step.
Strong encapsulation by default — Illegal reflective access to JDK internals is denied by default.
Packaging tool — jpackage builds native installers (.msi, .dmg, .deb, .rpm) for Java applications.
Stream.toList() — A shorter way to collect a stream into an unmodifiable list.

All changes in Java 16 (18)

Source: OpenJDK JDK 16 project ↗

Java 15

FeatureSeptember 2020

Text blocks are final, ZGC and Shenandoah become production-ready, and Nashorn is removed.

Featured

Text blocks — Multi-line string literals with """, ideal for JSON, SQL and HTML.
ZGC ready for production — The low-latency Z Garbage Collector is no longer experimental.
Shenandoah ready for production — The low-pause Shenandoah GC is no longer experimental.
Hidden classes — Classes that frameworks generate at run time and that other code cannot reference directly.
Sealed classes (preview) — The first preview of restricting which classes can extend a type.

All changes in Java 15 (14)

Source: OpenJDK JDK 15 project ↗

Java 14

FeatureMarch 2020

Switch expressions become final, NullPointerExceptions finally say what was null, and records appear in preview.

Featured

Switch expressions — switch can return a value and use case A, B -> arrows with no fall-through.
Helpful NullPointerExceptions — Messages name exactly which variable or call was null, such as because "user.address" is null.
Records (preview) — The first preview of compact data classes.
JFR event streaming — Consume Flight Recorder events continuously while the application runs.
CMS garbage collector removed — The Concurrent Mark Sweep collector, deprecated in Java 9, is gone.

All changes in Java 14 (16)

Source: OpenJDK JDK 14 project ↗

Java 13

FeatureSeptember 2019

A small release: text blocks appear in preview and the legacy socket implementation is rewritten.

Featured

Text blocks (preview) — The first preview of """ multi-line strings.
Dynamic CDS archives — Create a class-data sharing archive at application exit for faster startup.
Reimplemented legacy Socket API — A simpler, modern implementation behind java.net.Socket, preparing for virtual threads.

All changes in Java 13 (5)

Source: OpenJDK JDK 13 project ↗

Java 12

FeatureMarch 2019

Switch expressions appear in preview and the Shenandoah GC arrives as an experimental collector.

Featured

Switch expressions (preview) — The first preview of switch that returns a value.
Shenandoah GC (experimental) — A collector with pause times independent of heap size.
Default CDS archives — The JDK ships with a class-data sharing archive, so startup is faster out of the box.
New library methods — Collectors.teeing, String.indent, String.transform, Files.mismatch and compact number formatting.

All changes in Java 12 (9)

Source: OpenJDK JDK 12 project ↗

Java 11

LTSSeptember 2018

The first LTS under the six-month cadence. Adds the standard HTTP Client and single-file programs, and removes Java EE and CORBA modules. Oracle JDK became a commercial product and OpenJDK builds became the free option.

Featured

HTTP Client — java.net.http.HttpClient supports HTTP/1.1, HTTP/2, WebSocket, and synchronous and asynchronous calls.
Launch single-file programs — Run java Hello.java with no separate javac step.
`var` in lambda parameters — (var x, var y) -> x + y, which lets you add annotations to inferred parameters.
Java EE and CORBA modules removed — JAXB, JAX-WS, JavaBeans Activation and CORBA left the JDK; add them as dependencies instead.
Flight Recorder and TLS 1.3 — JFR became open source and free to use; TLS 1.3 support arrived.
New String and Files methods — isBlank, lines, strip, repeat, Files.readString and Files.writeString.

All changes in Java 11 (19)

Source: OpenJDK JDK 11 project ↗

Java 10

FeatureMarch 2018

The first release on the six-month schedule. It brought var for local variables and time-based version numbers.

Featured

Local-variable type inference (`var`) — var list = new ArrayList<String>(); lets the compiler infer the type of local variables.
Application class-data sharing — Share loaded application classes between JVMs for faster startup and lower memory use.
Parallel full GC for G1 — G1’s worst-case full collections use multiple threads.
Time-based release versioning — Versions follow the FEATURE.INTERIM.UPDATE.PATCH scheme and a release ships every six months.

All changes in Java 10 (13)

Source: OpenJDK JDK 10 project ↗

Java 9

FeatureSeptember 2017

The module system (Project Jigsaw) reorganized the JDK itself. Java 9 also added JShell and collection factory methods, and made G1 the default GC.

Featured

Java Platform Module System — module-info.java declares what a module requires and exports, giving reliable configuration and strong encapsulation.
JShell — An interactive REPL: type Java expressions and see results immediately.
Collection factory methods — List.of(1, 2, 3), Set.of(...) and Map.of(...) create small immutable collections.
G1 becomes the default GC — The Garbage-First collector replaces Parallel GC as the server default.
jlink — Build a custom, smaller runtime image that contains only the modules your application needs.
Small language changes — Private interface methods and effectively-final variables in try-with-resources.

All changes in Java 9 (91)

Source: OpenJDK JDK 9 project ↗

Java 8

LTSMarch 2014

The release that changed how Java is written: lambdas, streams and a new date-time API. Still widely used in legacy systems.

Featured

Lambda expressions and method references — list.forEach(x -> System.out.println(x)) and String::length pass behavior as values.
Streams — list.stream().filter(...).map(...).collect(...) processes collections declaratively, optionally in parallel.
Default methods in interfaces — Interfaces can contain method implementations, which let the collections API evolve without breaking code.
Date and time API (java.time) — LocalDate, Instant, Duration and ZonedDateTime replace the error-prone Date and Calendar.
Optional — Optional<T> makes “may be absent” explicit in return types.
Metaspace replaces PermGen — Class metadata moved to native memory, ending most OutOfMemoryError: PermGen space errors.

All changes in Java 8 (60)

Source: OpenJDK JDK 8 features ↗

Java SE 7

Major releaseJuly 2011 · “Dolphin”

The first release after Oracle acquired Sun, and the first built from OpenJDK. Small language improvements (Project Coin), NIO.2 and the fork/join framework.

Featured

try-with-resources — try (InputStream in = new FileInputStream(f)) { ... } closes resources automatically.
Diamond operator — Map<String, List<Integer>> m = new HashMap<>(); infers generic types on construction.
Strings in switch and multi-catch — switch works on String; catch (IOException | SQLException e) handles several exceptions at once.
NIO.2 file system API — Path, Files and WatchService replace much of java.io.File.
Fork/join framework — ForkJoinPool splits work recursively across CPU cores.
invokedynamic — A new bytecode instruction for dynamic languages; Java 8 lambdas are built on it.

All changes in Java SE 7 (24)

Source: OpenJDK JDK 7 features ↗

Java SE 6

Major releaseDecember 2006 · “Mustang”

Dropped the “J2SE” name. Focused on tooling, scripting, web services and desktop integration rather than language changes.

Featured

Scripting API — javax.script runs JavaScript and other scripting languages from Java; it shipped with Rhino.
Compiler API — javax.tools.JavaCompiler compiles Java source from inside a running program.
Pluggable annotation processing — Annotation processors run inside javac, the basis of tools like Lombok and MapStruct.
JDBC 4.0 — Drivers load automatically without Class.forName(...).
Web services in the JDK — JAX-WS 2.0 and JAXB 2.0 were bundled, later removed in Java 11.

All changes in Java SE 6 (17)

Source: JSR 270: Java SE 6 ↗

J2SE 5.0

Major releaseSeptember 2004 · “Tiger”

The biggest language update before Java 8: generics, annotations, enums, autoboxing, varargs and the enhanced for loop. Also known as Java 1.5.

Featured

Generics — List<String> gives type-safe collections checked at compile time.
Annotations — Metadata such as @Override and @Deprecated; the foundation for Spring, JPA and JUnit.
Enums — enum Color { RED, GREEN }: type-safe constants that can have fields and methods.
Enhanced for loop — for (String s : list) iterates arrays and collections.
Autoboxing and varargs — Automatic int ↔ Integer conversion, and methods like printf(String fmt, Object... args).
java.util.concurrent — Executors, thread pools, ConcurrentHashMap, locks and atomics.

All changes in J2SE 5.0 (22)

Source: JSR 176: J2SE 5.0 ↗

J2SE 1.4

Major releaseFebruary 2002 · “Merlin”

The first release developed through the Java Community Process. It added assertions, regular expressions, NIO and logging.

Featured

Assertions — assert x > 0 : "x must be positive"; checks assumptions during development.
Regular expressions — java.util.regex.Pattern and Matcher for searching and parsing text.
New I/O (NIO) — Buffers, channels and selectors for scalable, non-blocking I/O.
Logging API — java.util.logging brings built-in logging to the platform.
Exception chaining — Exceptions can carry their cause with getCause().

All changes in J2SE 1.4 (17)

Source: JSR 59: J2SE 1.4 ↗

J2SE 1.3

Major releaseMay 2000 · “Kestrel”

Performance and integration: HotSpot became the default JVM and JNDI and Java Sound joined the platform.

Featured

HotSpot JVM by default — Adaptive just-in-time compilation made Java much faster; HotSpot is still the JVM in most JDKs.
JNDI included — A standard API for naming and directory services such as LDAP.
Dynamic proxies — java.lang.reflect.Proxy creates interface implementations at run time, used by many frameworks.
Java Sound — Audio playback, recording and MIDI.

All changes in J2SE 1.3 (9)

Source: Java version history ↗

J2SE 1.2

Major releaseDecember 1998 · “Playground”

Branded “Java 2”. It tripled the size of the platform with the Collections Framework, Swing and Java 2D.

Featured

Collections Framework — List, Set, Map, ArrayList, HashMap and the algorithms in Collections.
Swing — A rich, platform-independent GUI toolkit built on AWT.
JIT compiler in the JVM — Sun’s JVM included a just-in-time compiler for the first time.
strictfp — A keyword for platform-independent floating-point results.

All changes in J2SE 1.2 (13)

Source: Java version history ↗

JDK 1.1

Major releaseFebruary 1997

Filled in the platform: inner classes, JDBC, RMI, reflection, serialization and JavaBeans.

Featured

Inner classes — Classes declared inside other classes, including anonymous classes for event listeners.
JDBC — A standard API for SQL databases.
Reflection — Inspect classes, fields and methods at run time.
Serialization and RMI — Turn objects into bytes, and call methods on objects in another JVM.
JavaBeans — A component model with properties and events, used by GUI builders.

All changes in JDK 1.1 (12)

Source: Java version history ↗

JDK 1.0

Major releaseJanuary 1996 · “Oak”

The first public release from Sun Microsystems. “Write once, run anywhere”: compile to bytecode and run it on any JVM.

Featured

The Java language — Classes, interfaces, single inheritance, exceptions and garbage collection, with C-like syntax.
The Java Virtual Machine — Compiled bytecode runs on any OS with a JVM.
Built-in threads — Thread and the synchronized keyword made concurrency part of the language.
Applets — Small programs that ran inside web browsers; removed in Java 26.

All changes in JDK 1.0 (8)

Source: Java version history ↗

About this page

WhichJava is a reference, not a course: we summarize each change in one line and link to the people who wrote it. For JDK 8 and later, “all changes” is the release’s complete JEP list plus notable library additions; earlier releases list their major features. Preview and incubator features can change before they become final. Spotted a mistake? See About & contact.

Choosing a version to install? See which Java version to use →