JavaFeatures.md

Java Features

Timeline of all JDK enhancements with respective JEP links. The entries are grouped by target JDK version and sorted by their number ascending.

This page is co-generated by AI. Please, report issues with links and/or descriptions if needed.

Java JDK 26

• JEP 500: Prepare to Make Final Mean Final

  • Issues warnings when deep reflection is used to mutate final fields, preparing the ecosystem for a future release that will restrict such mutations by default to improve program safety and enable performance optimizations.

• JEP 504: Remove the Applet API

  • Removes the obsolete Applet API (java.applet package, javax.swing.JApplet, and related classes), which was deprecated for removal in JDK 17 and is unusable since no modern browsers or JDK versions support applets.

• JEP 516: Ahead-of-Time Object Caching with Any GC

  • Enhances the ahead-of-time cache so it can be used with any garbage collector, including ZGC, by storing cached Java objects in a neutral, GC-agnostic format that is loaded sequentially into memory rather than mapped directly.

• JEP 517: HTTP/3 for the HTTP Client API

  • Updates the HTTP Client API to support the HTTP/3 protocol (based on QUIC), enabling faster handshakes, avoidance of head-of-line blocking, and more reliable transport, with opt-in usage and transparent downgrade to HTTP/2 or HTTP/1.1.

• JEP 522: G1 GC: Improve Throughput by Reducing Synchronization

  • Increases G1 garbage collector throughput by introducing a second card table to eliminate synchronization between application and GC optimizer threads, reducing write barrier size and yielding 5–15% throughput gains in heavy workloads.

• JEP 524: PEM Encodings of Cryptographic Objects (Second Preview)

  • Continues previewing the API for encoding and decoding cryptographic objects (keys, certificates, CRLs) to and from the PEM format, with refinements including renaming PEMRecord to PEM and enhanced EncryptedPrivateKeyInfo support.

• JEP 525: Structured Concurrency (Sixth Preview)

  • Continues previewing structured concurrency for grouping related concurrent tasks as single units of work, with minor API refinements including a new Joiner.onTimeout() method and allSuccessfulOrThrow() now returning a list of results.

• JEP 526: Lazy Constants (Second Preview)

  • Continues previewing the API for deferred immutability, renamed from StableValue to LazyConstant, re-oriented to focus on high-level use cases with lazy lists and maps moved to java.util.List and java.util.Map.

• JEP 529: Vector API (Eleventh Incubator)

  • Continues incubating the Vector API for expressing SIMD-style parallel operations that compile at runtime to optimal vector instructions on supported CPUs; awaiting Project Valhalla value classes before promotion to preview.

• JEP 530: Primitive Types in Patterns, instanceof, and switch (Fourth Preview)

  • Continues previewing support for primitive types in pattern matching, instanceof, and switch, with enhanced unconditional exactness definitions and tighter dominance checks in switch constructs.

Java JDK 25

• JEP 470: PEM Encodings of Cryptographic Objects (Preview)

  • Adds a preview API in java.security to convert cryptographic objects (keys, certificates, CRLs) to and from the PEM textual format (Base64 plus headers).

• JEP 502: Stable Values (Preview)

  • Introduces a mechanism for declaring values as stable (i.e. immutable and cached) across execution to enable optimizations and reduce redundant computations.

• JEP 503: Remove the 32-bit x86 Port

  • Removes support for the 32-bit x86 platform entirely from the JDK (no builds, no runtime).

• JEP 505: Structured Concurrency (Fifth Preview)

  • Continues previewing structured concurrency (for virtual threads), which allows grouping tasks with better error propagation and lifecycle control.

• JEP 506: Scoped Values

  • Finalizes (removes preview status) scoped values, a lighter-weight alternative to thread-locals for propagating immutable data across call chains and threads.

• JEP 507: Primitive Types in Patterns, instanceof, and switch (Third Preview)

  • Extends pattern matching, instanceof, and switch to support primitive types uniformly (not just reference types).

• JEP 508: Vector API (Tenth Incubator)

  • Continues incubating the Vector API for expressing SIMD-style parallel operations; JDK 25 version adds native linking to math libraries and improvements for Float16 operations.

• JEP 509: JFR CPU-Time Profiling (Experimental)

  • Adds experimental support to Java Flight Recorder (JFR) for profiling actual CPU time consumed by threads, refining profiling accuracy beyond wall-clock time.

• JEP 510: Key Derivation Function API

  • Provides a standardized API for key derivation functions (KDFs) like HKDF, making modern cryptographic practices easier to use and more consistent.

• JEP 511: Module Import Declarations

  • Adds import module M syntax to allow importing an entire module’s exported packages in a Java source file (outside module-info) to simplify modular reuse.

• JEP 512: Compact Source Files and Instance Main Methods

  • Improves the “on-ramp” for Java by allowing simple source files (no need for public class) and allowing instance main methods to reduce ceremony in small programs.

• JEP 513: Flexible Constructor Bodies

  • Permits statements before the super(...) or this(...) call in a constructor body (with restrictions), improving initialization expressiveness and safety.

• JEP 514: Ahead-of-Time Command-Line Ergonomics

  • Improves command-line usability of AOT (jaotc / jcmd / java -XX:AOT...) tools in terms of default settings, error handling, and ergonomics.

• JEP 515: Ahead-of-Time Method Profiling

  • Introduces profiling of hot methods during AOT image generation to inform improved code layout and performance in the generated images.

• JEP 518: JFR Cooperative Sampling

  • Adds a cooperative sampling mode to JFR that allows lower-overhead data collection by sampling execution voluntarily rather than interrupting threads.

• JEP 519: Compact Object Headers

  • Applies the object-header compaction (reducing header size) design into the JVM to shrink memory footprint and improve object layout efficiency.

• JEP 520: JFR Method Timing & Tracing

  • Enhances JFR with fine-grained method timing and trace events to better observe method-level performance and interactions.

• JEP 521: Generational Shenandoah

  • Brings generational collection support to Shenandoah GC (i.e. separating young/old generations) to improve throughput and reduce pause times in typical workloads.

Java JDK 24

• JEP 404: Generational Shenandoah (Experimental)

  • Adds a generational mode to the Shenandoah GC (i.e. separating young/old generations) to improve throughput, reduce overhead, and better handle allocation spikes.

• JEP 450: Compact Object Headers (Experimental)

  • Reduces the memory footprint of object headers (aiming to compress them into ~64 bits) to conserve memory and improve efficiency.

• JEP 472: Prepare to Restrict the Use of JNI

  • Introduces runtime warnings when JNI is used and paves the way for stronger restrictions in future releases.

• JEP 475: Late Barrier Expansion for G1

  • Enhances the G1 garbage collector by expanding its write barriers later, reducing overhead and improving performance in certain workloads.

• JEP 478: Key Derivation Function API (Preview)

  • Provides a standard API for key derivation functions (KDFs), e.g. HKDF, to support modern cryptographic needs.

• JEP 479: Remove the Windows 32-bit x86 Port

  • Drops support for building and running on 32-bit x86 Windows platforms.

• JEP 483: Ahead-of-Time Class Loading & Linking

  • Moves class loading and linking work to startup time (ahead of execution) to improve application launch performance.

• JEP 484: Class-File API

  • Offers an API to read, modify, and generate Java class-file structures programmatically.

• JEP 485: Stream Gatherers

  • Introduces a new mechanism for defining custom intermediate stream operations via “gatherers”.

• JEP 486: Permanently Disable the Security Manager

  • Fully disables the outdated Security Manager mechanism (which had been deprecated) and removes its functionality.

• JEP 487: Scoped Values (Fourth Preview)

  • Introduces scoped values (a lightweight alternative to thread-locals) to propagate contextual data without polluting method signatures.

• JEP 488: Primitive Types in Patterns, instanceof, and switch (Second Preview)

  • Extends pattern matching, instanceof, and switch to support primitive types, making the language more uniform.

• JEP 489: Vector API (Ninth Incubator)

  • Continues evolution of the Vector API (for SIMD‐style operations) under incubator status for further experimentation.

• JEP 490: ZGC: Remove the Non-Generational Mode

  • Removes support for the non-generational mode in ZGC, making generational mode the only available mode.

• JEP 491: Synchronize Virtual Threads without Pinning

  • Enables synchronization in virtual threads without “pinning” (i.e. reserving a carrier thread), improving resource efficiency.

• JEP 492: Flexible Constructor Bodies (Third Preview)

  • Allows statements before the explicit super(...) or this(...) call in constructor bodies (with restrictions) to improve initialization flexibility.

• JEP 493: Linking Run-Time Images without JMODs

  • Enables creating runtime images (via jlink) that do not require the JMOD infrastructure, reducing image size.

• JEP 494: Module Import Declarations (Second Preview)

  • Adds a language-level import module M syntax to import all exported packages from a module, simplifying module reuse.

• JEP 495: Simple Source Files and Instance Main Methods (Fourth Preview)

  • Simplifies Java programs by removing the need for public class or static main(String[]) boilerplate in simple files.

• JEP 496: Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism

  • Integrates a post-quantum KEM (e.g. based on module-lattice cryptography) into the standard JDK crypto APIs.

• JEP 497: Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm

  • Adds a post-quantum digital signature algorithm (based on module-lattice cryptography) to JDK cryptographic support.

• JEP 498: Warn upon Use of Memory-Access Methods in sun.misc.Unsafe

  • Emits a runtime warning the first time deprecated memory-access methods in sun.misc.Unsafe are called, encouraging migration to supported APIs.

• JEP 499: Structured Concurrency (Fourth Preview)

  • Continues preview of structured concurrency for virtual threads, enabling better error propagation and task grouping.

• JEP 501: Deprecate the 32-bit x86 Port for Removal

  • Marks the remaining Linux 32-bit x86 port as deprecated and intends its removal in a future release.

Java JDK 23

• JEP 455: Primitive Types in Patterns, instanceof, and switch (Preview)

  • Modifies the Java language to support the use of primitive types in patterns, instanceof, and switch statements, improving their utility and consistency.

• JEP 466: Class-File API (Second Preview)

  • Introduces a new API for generating and parsing Java class files, leveraging pattern matching to simplify the manipulation of bytecode.

• JEP 467: Markdown Documentation Comments

  • Introduces the use of Markdown for writing API documentation comments, aiming to enhance readability and maintainability.

• JEP 469: Vector API (Eighth Incubator)

  • Continues to iterate on the Vector API, focusing on enhancing performance and expandability of SIMD (Single Instruction, Multiple Data) operations.

• JEP 473: Stream Gatherers (Second Preview)

  • Enhances the Stream API to efficiently gather elements into collections with improved control over the characteristics of these collections.

• JEP 471: Deprecate the Memory-Access Methods in sun.misc.Unsafe for Removal

  • Marks the unsafe memory-access methods from the sun.misc.Unsafe class for future removal, guiding usage towards safer alternatives.

• JEP 474: ZGC: Generational Mode by Default

  • Makes generational mode the default for the Z Garbage Collector to improve performance and efficiency in garbage collection.

• JEP 476: Module Import Declarations (Preview)

  • Introduces a feature to import entire modules, enhancing modularity and clarity in module dependencies.

• JEP 477: Implicitly Declared Classes and Instance Main Methods (Third Preview)

  • Expands the language to support implicitly declared classes and instance main methods, simplifying certain programming models.

• JEP 480: Structured Concurrency (Third Preview)

  • Aims to simplify multithreaded programming by treating multiple tasks as a single unit of work, thus improving error handling and cancellation.

• JEP 481: Scoped Values (Third Preview)

  • Enhances thread-local storage by introducing scoped values, which improve performance and manageability of thread-confined data.

• JEP 482: Flexible Constructor Bodies (Second Preview)

  • Allows more flexibility in constructors by supporting early field assignments and extending the context in which certain code elements can be used.

Java JDK 22

• JEP 423: Region Pinning for G1

  • Reduce latency by implementing region pinning in G1, enabling garbage collection to proceed without being disabled during Java Native Interface (JNI) critical regions.

• JEP 447: Statements before super(...) (Preview)

  • Allow statements that do not reference the instance being created to appear before an explicit constructor invocation in the Java programming language.

• JEP 454: Foreign Function & Memory API

  • Introduce an API for Java programs to interoperate with code and data outside of the Java runtime, allowing efficient invocation of foreign functions and safe access to foreign memory.

• JEP 456: Unnamed Variables & Patterns

  • Enhance the Java programming language with unnamed variables and patterns, using the underscore character for declarations or nested patterns that are required but never used.

• JEP 457: Class-File API (Preview)

  • Provide a standard API for parsing, generating, and transforming Java class files, facilitating program analysis and transformation.

• JEP 458: Launch Multi-File Source-Code Programs

  • Enhance the java launcher to run programs supplied as multiple files of Java source code, simplifying the transition from small to larger programs.

• JEP 459: String Templates (Second Preview)

  • Introduce string templates to the Java programming language, coupling literal text with embedded expressions and template processors.

• JEP 460: Vector API (Seventh Incubator)

  • Introduce an API to express vector computations that compile at runtime to optimal vector instructions on supported CPU architectures.

• JEP 461: Stream Gatherers (Preview)

  • Enhance the Stream API to support custom intermediate operations, allowing for more flexible data transformation in stream pipelines.

• JEP 462: Structured Concurrency (Second Preview)

  • Introduce an API for structured concurrency, simplifying concurrent programming by treating groups of related tasks as a single unit of work.

• JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview)

  • Evolve the Java programming language to allow beginners to write programs without understanding complex features, enabling a seamless expansion of their programs as their skills grow.

• JEP 464: Scoped Values (Second Preview)

  • Introduce scoped values for managed sharing of immutable data, offering a more efficient and easier to understand alternative to thread-local variables.

Java JDK 21 (LTS)

• JEP 430: String Templates (Preview)

  • Introduces string templates as a preview feature, aiming to simplify string formatting and interpolation.

• JEP 431: Sequenced Collections

  • Adds sequenced collections to the Java Collections Framework, providing a new way to handle ordered collections.

• JEP 439: Generational ZGC

  • Introduces generational capabilities to the Z Garbage Collector, aiming to improve its performance.

• JEP 440: Record Patterns

  • Finalizes the record patterns feature, simplifying the destructuring of records and improving code readability.

• JEP 441: Pattern Matching for switch

  • Finalizes the pattern matching for switch feature, making code more readable and maintainable.

• JEP 442: Foreign Function & Memory API (Third Preview)

  • Continues the preview of the Foreign Function & Memory API, aiming to improve the connection between Java and native libraries.

• JEP 443: Unnamed Patterns and Variables (Preview)

  • Introduces unnamed patterns and variables as a preview feature, aiming to simplify pattern matching.

• JEP 444: Virtual Threads

  • Finalizes the virtual threads feature, simplifying the handling of concurrency in Java applications.

• JEP 445: Unnamed Classes and Instance Main Methods (Preview)

  • Introduces unnamed classes and instance main methods as a preview feature, aiming to simplify class definitions and object instantiation.

• JEP 446: Scoped Values (Preview)

  • Continues the preview of scoped values, aiming to provide a mechanism for associating values with a thread's execution scope.

• JEP 448: Vector API (Sixth Incubator)

  • Continues the incubation of the Vector API, aiming to provide a mechanism for expressing vector computations that compile to optimized vector hardware instructions.

• JEP 449: Deprecate the Windows 32-bit x86 Port for Removal

  • Deprecates the Windows 32-bit x86 port, signaling its future removal from the JDK.

• JEP 451: Prepare to Disallow the Dynamic Loading of Agents

  • Prepares for the disallowance of dynamic loading of agents, enhancing security.

• JEP 452: Key Encapsulation Mechanism API

  • Introduces a Key Encapsulation Mechanism API, aiming to improve cryptographic capabilities.

• JEP 453: Structured Concurrency (Preview)

  • Continues the preview of structured concurrency, aiming to make it easier to write concurrent programs by structuring asynchronous computation.

Java JDK 20

• JEP 429: Scoped Values (Incubator)

  • Introduces scoped values as an incubator feature, aiming to provide a mechanism for associating values with a thread's execution scope.

• JEP 432: Record Patterns (Second Preview)

  • Continues the preview of record patterns, aiming to simplify the destructuring of records and improve code readability.

• JEP 433: Pattern Matching for switch (Fourth Preview)

  • Continues the preview of pattern matching in switch expressions, aiming to make code more readable and maintainable.

• JEP 434: Foreign Function & Memory API (Second Preview)

  • Continues the preview of the Foreign Function & Memory API, aiming to improve the connection between Java and native libraries.

• JEP 436: Virtual Threads (Second Preview)

  • Continues the preview of virtual threads, aiming to simplify concurrency by making it easier to handle many tasks.

• JEP 437: Structured Concurrency (Second Incubator)

  • Continues the incubation of structured concurrency, aiming to make it easier to write concurrent programs by structuring asynchronous computation.

• JEP 438: Vector API (Fifth Incubator)

  • Continues the incubation of the Vector API, which aims to provide a mechanism for expressing vector computations that compile to optimized vector hardware instructions.

Java JDK 19

• JEP 405: Record Patterns (Preview)

  • Introduces record patterns to simplify the destructuring of records, enhancing code readability and reducing boilerplate.

• JEP 422: Linux/RISC-V Port

  • Adds a Linux port for the RISC-V architecture, expanding the platform support for Java.

• JEP 424: Foreign Function & Memory API (Preview)

  • Continues the incubation of the Foreign Function & Memory API, aiming to improve the connection between Java and native libraries.

• JEP 425: Virtual Threads (Preview)

  • Introduces virtual threads as a preview feature, aiming to simplify concurrency by making it easier to handle many tasks.

• JEP 426: Vector API (Fourth Incubator)

  • Continues the incubation of the Vector API, which aims to provide a mechanism for expressing vector computations that compile to optimized vector hardware instructions.

• JEP 427: Pattern Matching for switch (Third Preview)

  • Continues the preview of pattern matching in switch expressions, aiming to make code more readable and maintainable.

• JEP 428: Structured Concurrency (Incubator)

  • Introduces structured concurrency as an incubator feature, aiming to make it easier to write concurrent programs by structuring asynchronous computation.

Java JDK 18

• JEP 400: UTF-8 by Default

  • Changes the default charset to UTF-8, aiming to simplify the encoding and decoding of text files and reduce the confusion surrounding charset handling.

• JEP 408: Simple Web Server

  • Introduces a simple web server in the JDK, primarily for use in development and testing environments, making it easier to work with HTTP-based services.

• JEP 413: Code Snippets in Java API Documentation

  • Adds the ability to include code snippets in Java API documentation, enhancing the quality and clarity of the documentation.

• JEP 416: Reimplement Core Reflection with Method Handles

  • Reimplements the core reflection API using method handles, aiming to improve performance and maintainability.

• JEP 417: Vector API (Third Incubator)

  • Continues the incubation of the Vector API, which aims to provide a mechanism for expressing vector computations that reliably compile to optimized vector hardware instructions.

• JEP 418: Internet-Address Resolution SPI

  • Introduces a Service Provider Interface (SPI) for internet-address resolution, allowing for custom resolution strategies.

• JEP 419: Foreign Function & Memory API (Second Incubator)

  • Continues the incubation of the Foreign Function & Memory API, aiming to improve the connection between Java and native libraries.

• JEP 420: Pattern Matching for switch (Second Preview)

  • Enhances the switch expression by introducing pattern matching capabilities, making code more readable and maintainable.

• JEP 421: Deprecate Finalization for Removal

  • Deprecates the finalization feature for future removal, encouraging developers to use better alternatives for resource management.

Java JDK 17 (LTS)

• JEP 306: Restore Always-Strict Floating-Point Semantics

  • Restores the always-strict floating-point semantics to the Java language and the JVM.

• JEP 356: Enhanced Pseudo-Random Number Generators

  • Introduces new interfaces and implementations for random number generation in the java.util.random package.

• JEP 382: New macOS Rendering Pipeline

  • Introduces a new rendering pipeline for macOS based on Apple's Metal framework.

• JEP 391: macOS/AArch64 Port

  • Adds a macOS/AArch64 port to the JDK.

• JEP 398: Deprecate the Applet API for Removal

  • Deprecates the Applet API, signaling its future removal from the JDK.

• JEP 403: Strongly Encapsulate JDK Internals

  • Strongly encapsulates all internal elements of the JDK, except for critical internal APIs.

• JEP 406: Pattern Matching for switch (Preview)

  • Introduces pattern matching for the switch statement as a preview feature.

• JEP 407: Remove RMI Activation

  • Removes the RMI Activation system, while preserving the rest of RMI.

• JEP 409: Sealed Classes

  • Enhances the Java programming language with sealed classes and interfaces.

• JEP 410: Remove the Experimental AOT and JIT Compiler

  • Removes the experimental Ahead-of-Time (AOT) and Just-in-Time (JIT) compiler.

• JEP 411: Deprecate the Security Manager for Removal

  • Deprecates the Security Manager and the API tied to it for future removal.

• JEP 412: Foreign Function & Memory API (Incubator)

  • Introduces an API to allow Java programs to interact with native code and memory.

• JEP 414: Vector API (Second Incubator)

  • Continues the incubation of the Vector API, aiming to express vector computations that compile to optimized vector hardware instructions.

• JEP 415: Context-Specific Deserialization Filters

  • Enhances the deserialization filtering mechanism by allowing context-specific, user-defined filters.

Java JDK 16

• JEP 338: Vector API (Incubator)

  • Introduces an initial iteration of an incubating vector API that aims to express a range of vector computations in a performant and portable manner.

• JEP 347: Enable C++14 Language Features

  • Allows the use of C++14 language features in JDK C++ source code, enabling the use of new language features, library APIs, and improved diagnostics.

• JEP 357: Migrate from Mercurial to Git

  • Migrates the OpenJDK Community's source code repositories from Mercurial to Git, aiming for a simpler and more performant system.

• JEP 369: Migrate to GitHub

  • Hosts the OpenJDK Community's Git repositories on GitHub for enhanced tooling, issue tracking, and improved collaboration.

• JEP 376: ZGC: Concurrent Thread-Stack Processing

  • Moves ZGC thread-stack processing from safepoints to a concurrent phase, thereby reducing ZGC safepoint times.

• JEP 380: Unix-Domain Socket Channels

  • Adds support for Unix-domain socket channels, providing feature parity with existing support in the networking API for other protocols.

• JEP 386: Alpine Linux Port

  • Provides a port of the JDK to Alpine Linux, a security-oriented, lightweight Linux distribution, and to other Linux distributions that use musl as their primary C library.

• JEP 387: Elastic Metaspace

  • Returns unused HotSpot class-metadata (metaspace) memory to the operating system more promptly, reducing metaspace footprint.

• JEP 388: Windows/AArch64 Port

  • Adds a Windows/AArch64 port to the JDK, extending the availability of the JDK on different architectures and operating systems.

• JEP 389: Foreign Function & Memory API (Incubator)

  • An incubating feature aiming to simplify and make safer the interaction between Java and native libraries.

• JEP 390: Warnings for Value-Based Classes

  • Provides a lint warning for value-based classes that may become records in the future, warning developers of future incompatibilities.

• JEP 392: Packaging Tool

  • Provides the jpackage tool for packaging self-contained Java applications, elevating it from an incubating feature in JDK 14 to a standard feature.

• JEP 393: Foreign-Memory Access API (Third Incubator)

  • Third incubation of an API that enables efficient, safe and concise access to native memory segments from Java code.

• JEP 394: Pattern Matching for instanceof

  • Finalizes the pattern matching for instanceof feature introduced in earlier JDK versions, improving code readability and safety.

• JEP 395: Records

  • Introduces records to provide a compact syntax for declaring classes which are intended to be immutable data carriers.

• JEP 396: Strongly Encapsulate JDK Internals

  • Strongly encapsulates all internal elements of the JDK, except for critical internal APIs such as sun.misc.Unsafe, to improve security and maintainability.

Java JDK 15

• JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA)

  • Adds an implementation of the EdDSA (Edwards-Curve Digital Signature Algorithm) to the list of supported signature algorithms in the JDK.

• JEP 360: Sealed Classes (Preview)

  • Introduces sealed classes as a preview feature. Sealed classes are classes that have a limited set of subclasses, providing more fine-grained control over inheritance.

• JEP 371: Hidden Classes

  • Introduces hidden classes, which are classes that cannot be directly used by the bytecode of other classes. This is beneficial for frameworks that generate classes at runtime.

• JEP 372: Remove the Nashorn JavaScript Engine

  • Removes the Nashorn JavaScript script engine and its APIs, encouraging users to migrate to more modern solutions for JavaScript execution on the JVM.

• JEP 373: Reimplement the Legacy DatagramSocket API

  • Provides a new implementation of the legacy java.net.DatagramSocket API, replacing the underlying native implementation for improved maintainability.

• JEP 374: Disable and Deprecate Biased Locking

  • Deprecates the Biased Locking feature in the HotSpot virtual machine and disables it by default, as it has become less relevant for modern hardware.

• JEP 375: Pattern Matching for instanceof (Second Preview)

  • Offers a second preview of pattern matching for the instanceof operator, aiming to improve code readability by reducing boilerplate code.

• JEP 377: ZGC: A Scalable Low-Latency Garbage Collector

  • Moves ZGC (Z Garbage Collector) from an experimental feature to a product feature, offering scalability with low-latency.

• JEP 378: Text Blocks

  • Finalizes the Text Blocks feature that was previewed in earlier JDK versions, simplifying the handling of multiline string literals.

• JEP 379: Shenandoah: A Low-Pause-Time Garbage Collector

  • Moves Shenandoah, a garbage collector designed to provide low-pause-time, from an experimental feature to a product feature.

• JEP 381: Remove the Solaris and SPARC Ports

  • Removes the source code and build support for the Solaris/SPARC, Solaris/x64, and Linux/SPARC ports to focus on more relevant platforms.

• JEP 383: Foreign-Memory Access API (Second Incubator)

  • Second incubation of an API to allow Java programs to safely and efficiently access foreign memory outside of the Java heap.

• JEP 384: Records (Second Preview)

  • Offers a second preview of records, aiming to provide a compact syntax for declaring immutable data classes.

• JEP 385: Deprecate RMI Activation for Removal

  • Deprecates RMI (Remote Method Invocation) Activation for future removal, as part of the effort to simplify the RMI API.

Java JDK 14

• JEP 305: Pattern Matching for instanceof (Preview)

  • Adds a preview of pattern matching for the instanceof operator, allowing more expressive and safe code constructs.

• JEP 343: Packaging Tool (Incubator)

  • Introduces an incubating tool for packaging self-contained Java applications, allowing distribution with all dependencies included.

• JEP 345: NUMA-Aware Memory Allocation for G1

  • Improves the G1 garbage collector to automatically allocate memory from multiple NUMA nodes to improve performance on multi-socket machines.

• JEP 349: JFR Event Streaming

  • Enhances the JDK Flight Recorder (JFR) with event streaming capabilities, allowing continuous consumption of JFR data.

• JEP 352: Non-Volatile Mapped Byte Buffers

  • Adds new FileChannel API methods that allow Java programs to map, unmap, and synchronize content to a file directly from native memory.

• JEP 358: Helpful NullPointerExceptions

  • Enhances the information provided by NullPointerExceptions by describing which variable was null, aiding in debugging.

• JEP 359: Records (Preview)

  • Adds a preview feature of records to the Java language, providing a compact syntax for declaring classes meant to be immutable data carriers.

• JEP 361: Switch Expressions

  • Adds the switch expression, previously previewed, as a standard language feature to simplify everyday coding tasks.

• JEP 362: Deprecate the Solaris and SPARC Ports

  • Deprecates the Solaris and SPARC ports with the intent to remove them in a future release.

• JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector

  • Removes the CMS garbage collector, which had been deprecated in JDK 9, to focus on improving G1 and other modern garbage collectors.

• JEP 364: ZGC on macOS

  • Adds Z Garbage Collector (ZGC) support for macOS, expanding its availability to additional platforms.

• JEP 365: ZGC on Windows

  • Adds Z Garbage Collector (ZGC) support for Windows, expanding its availability to additional platforms.

• JEP 366: Deprecate the ParallelScavenge + SerialOld GC Combination

  • Deprecates the combination of the Parallel Scavenge and Serial Old garbage collection algorithms.

• JEP 367: Remove the Pack200 Tools and API

  • Removes the pack200 and unpack200 tools, along with the related Pack200 API in java.util.jar.Pack200.

• JEP 368: Text Blocks (Second Preview)

  • Provides a second preview of Text Blocks, aiming to simplify the task of writing Java programs that deal with code in string form.

• JEP 370: Foreign-Memory Access API (Incubator)

  • Introduces an incubating API that enables Java programs to safely and efficiently access foreign memory outside of the Java heap.

Java JDK 13

• JEP 350: Dynamic CDS Archives

  • Extends the existing Class-Data Sharing ("CDS") feature to allow dynamic archiving of classes at the end of Java application execution. This aims to improve the startup time for short-running Java applications.

• JEP 351: ZGC: Uncommit Unused Memory

  • Enhances the Z Garbage Collector to return unused heap memory to the operating system, aiming for improved resource utilization and better co-existence with other processes.

• JEP 353: Reimplement the Legacy Socket API

  • Provides a new implementation for the legacy java.net.Socket and java.net.ServerSocket APIs, replacing the underlying native implementation for better maintainability.

• JEP 354: Switch Expressions (Preview)

  • Introduces a preview of the new switch expression, a more concise and safe alternative to the existing switch statement.

• JEP 355: Text Blocks (Preview)

  • Introduces a preview of text blocks to simplify the task of writing Java programs that deal with multi-line string literals, while also improving their readability and maintainability.

Java JDK 12

• JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)

  • Introduces Shenandoah as an experimental garbage collector. Shenandoah aims to provide low-latency garbage collection for large heaps.

• JEP 230: Microbenchmark Suite

  • Adds a suite of microbenchmarks to the JDK source code, aimed to help developers write high-performance code.

• JEP 325: Switch Expressions (Preview)

  • Introduces a preview of switch expressions, which simplify coding by extending the switch statement so it can be used as either a statement or an expression.

• JEP 334: JVM Constants API

  • Introduces an API that allows JVM languages to model nominal descriptions of key class-file and run-time artifacts, commonly constants.

• JEP 340: One AArch64 Port, Not Two

  • Removes all of the sources related to the arm64 port while retaining the 64-bit ARM (aarch64) port to eliminate confusion between two similar-sounding ports.

• JEP 341: Default CDS Archives

  • Enhances the JDK build process to generate a class data-sharing (CDS) archive using the default class list, aiming to improve startup performance.

• JEP 344: Abortable Mixed Collections for G1

  • Makes G1 mixed collections abortable, enhancing G1's ability to meet the soft real-time goals by making it more predictable.

• JEP 346: Promptly Return Unused Committed Memory from G1

  • Enhances the G1 garbage collector to automatically return unused committed memory back to the operating system more promptly.

Java JDK 11 (LTS)

• JEP 181: Nest-Based Access Control

  • Introduces nest-based access control to improve the readability and maintainability of nested classes.

• JEP 309: Dynamic Class-File Constants

  • Adds dynamic constants to the Java class-file format to support languages that require dynamically-computed constants.

• JEP 315: Improve Aarch64 Intrinsics

  • Enhances the existing string and array intrinsics on AArch64 processors for better performance.

• JEP 318: Epsilon: A No-Op Garbage Collector

  • Introduces a no-op garbage collector for testing and benchmarking purposes.

• JEP 320: Remove the Java EE and CORBA Modules

  • Removes Java EE and CORBA modules from the Java Standard Edition.

• JEP 321: HTTP Client (Standard)

  • Standardizes the HTTP Client API, which was introduced as an incubator module in JDK 9.

• JEP 323: Local-Variable Syntax for Lambda Parameters

  • Allows var to be used when declaring the formal parameters of implicitly typed lambda expressions.

• JEP 324: Key Agreement with Curve25519 and Curve448

  • Implements key agreement using Curve25519 and Curve448 as described in RFC 7748.

• JEP 327: Unicode 10

  • Updates the existing platform APIs to support Unicode 10.0.

• JEP 328: Flight Recorder

  • Provides a low-overhead data collection framework for troubleshooting Java applications and the HotSpot JVM.

• JEP 329: ChaCha20 and Poly1305 Cryptographic Algorithms

  • Implements the ChaCha20 and Poly1305 cryptographic algorithms.

• JEP 330: Launch Single-File Source-Code Programs

  • Enhances the java launcher to run a program supplied as a single file of Java source code.

• JEP 331: Low-Overhead Heap Profiling

  • Provides a low-overhead way of sampling Java heap allocations, accessible via JVMTI.

• JEP 332: Transport Layer Security (TLS) 1.3

  • Implements version 1.3 of the Transport Layer Security (TLS) Protocol.

• JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)

  • Introduces a new garbage collector, ZGC, designed for low latency and scalability.

• JEP 335: Deprecate the Nashorn JavaScript Engine

  • Deprecates the Nashorn JavaScript script engine and APIs.

• JEP 336: Deprecate the Pack200 Tools and API

  • Deprecates the pack200 and unpack200 tools, and the Pack200 API in java.util.jar.

Java JDK 10

• JEP 286: Local-Variable Type Inference

  • Introduces var keyword to infer the type of local variables, reducing boilerplate code.

• JEP 296: Consolidate the JDK Forest into a Single Repository

  • Consolidates multiple repositories of the JDK forest into a single repository to simplify and streamline development.

• JEP 304: Garbage-Collector Interface

  • Introduces a clean garbage collector interface, making it easier to add a new GC without altering the rest of the codebase.

• JEP 307: Parallel Full GC for G1

  • Adds parallelism to the full GC operation for G1 to improve its performance.

• JEP 310: Application Class-Data Sharing

  • Extends class-data sharing to allow application classes to be placed in the shared archive to improve startup and footprint.

• JEP 312: Thread-Local Handshakes

  • Adds a way to execute a callback on threads without performing a global VM safepoint, making it easier to stop individual threads.

• JEP 313: Remove the Native-Header Generation Tool (javah)

  • Removes the javah tool, as its functionality has been subsumed by javac.

• JEP 314: Additional Unicode Language-Tag Extensions

  • Enhances java.util.Locale and related APIs to implement additional Unicode extensions of BCP 47 language tags.

• JEP 316: Heap Allocation on Alternative Memory Devices

  • Enables the HotSpot VM to allocate the Java object heap on an alternative memory device, specified by the user.

• JEP 317: Experimental Java-Based JIT Compiler

  • Adds an experimental Just-In-Time (JIT) compiler written in Java.

• JEP 319: Root Certificates

  • Provides a default set of root Certification Authority (CA) certificates in the JDK.

• JEP 322: Time-Based Release Versioning

  • Introduces a time-driven release model, with a new feature release every six months.

Java JDK 9

• JEP 102: Process API Updates

  • Enhances the java.lang.Process API, making it easier to control and manage operating system processes.

• JEP 110: HTTP/2 Client

  • Introduces a new HTTP client API that supports HTTP/2 and WebSocket, replacing the legacy HttpURLConnection API.

• JEP 143: Improve Contended Locking

  • Optimizes the performance of contended Java object monitors.

• JEP 158: Unified JVM Logging

  • Introduces a common logging system for all components of the JVM.

• JEP 165: Compiler Control

  • Provides enhanced control of JVM compilers through new options and directives.

• JEP 193: Variable Handles

  • Offers a new set of APIs for performing atomic operations and managing variables at a lower level.

• JEP 197: Segmented Code Cache

  • Divides the code cache into distinct segments, each containing compiled code of a particular type, to improve performance.

• JEP 199: Smart Java Compilation, Phase Two

  • Enhances the sjavac tool to improve the build speed of large projects.

• JEP 200: The Modular JDK

  • Modularizes the JDK into a set of modules that can be combined at compile time, build time, or run time.

• JEP 211: Elide Deprecation Warnings on Import Statements

  • Allows developers to elide deprecation warnings for import statements.

• JEP 213: Milling Project Coin

  • Introduces small language changes to simplify coding.

• JEP 214: Remove GC Combinations Deprecated in JDK 8

  • Removes the deprecated garbage collection combinations.

• JEP 215: Tiered Attribution for javac

  • Enhances javac to support different levels of attribution for different phases of compilation.

• JEP 216: Process Import Statements Correctly

  • Fixes the javac compiler to correctly process import statements as per the Java Language Specification.

• JEP 217: Annotations Pipeline 2.0

  • Revises the annotation-processing pipeline in the javac compiler.

• JEP 219: Datagram Transport Layer Security (DTLS)

  • Implements Datagram Transport Layer Security (DTLS) in the JDK.

• JEP 220: Modular Run-Time Images

  • Reorganizes the JDK and JRE run-time images to accommodate modules.

• JEP 221: Simplified Doclet API

  • Introduces a new, simplified Doclet API for easier generation of custom Javadoc tags.

• JEP 222: jshell: The Java Shell

  • Adds a Read-Eval-Print Loop (REPL) for the Java programming language.

• JEP 223: New Version-String Scheme

  • Introduces a new version-string scheme to make it easier to distinguish major, minor, and security-update releases.

• JEP 224: HTML5 Javadoc

  • Enhances the Javadoc tool to generate HTML5 markup.

• JEP 225: Javadoc Search

  • Adds a search box to the Javadoc tool to make it easier to navigate API documentation.

• JEP 226: UTF-8 Property Files

  • Enhances the java.util.Properties class to support UTF-8 encoded property files.

• JEP 227: Unicode 7.0

  • Updates the JDK to support version 7.0 of the Unicode Standard.

• JEP 228: Add More Diagnostic Commands

  • Adds additional diagnostic commands to improve the ability to diagnose issues with HotSpot and the JDK.

• JEP 229: Create PKCS12 Keystores by Default

  • Changes the default keystore type to PKCS12.

• JEP 231: Remove Launch-Time JRE Version Selection

  • Removes the ability to request a specific JRE version when launching an application.

• JEP 232: Improve Secure Application Performance

  • Improves the performance of applications that use cryptographic algorithms.

• JEP 233: Generate Run-Time Compiler Tests Automatically

  • Enhances the JDK build process to generate compiler tests automatically.

• JEP 235: Test Class-File Attributes Generated by javac

  • Adds a set of tests to verify the class-file attributes generated by the javac compiler.

• JEP 236: Parser API for Nashorn

  • Provides a supported API to parse ECMAScript code.

• JEP 237: Linux/RISC-V Port

  • Adds a Linux port of the JDK for the RISC-V architecture.

• JEP 238: Multi-Release JAR Files

  • Extends the JAR file format to allow multiple, Java-release-specific versions of class files.

• JEP 239: Remove the Applet API

  • Deprecates the Applet API for removal in a future release.

• JEP 240: Remove the JVM TI hprof Agent

  • Removes the hprof agent from the JDK.

• JEP 241: Remove the jhat Tool

  • Removes the jhat tool from the JDK.

• JEP 243: Java-Level JVM Compiler Interface

  • Introduces a Java-level JVM Compiler Interface (JVMCI) to enable the development of a Java-based JIT compiler.

• JEP 244: TLS Application-Layer Protocol Negotiation Extension

  • Implements the TLS Application-Layer Protocol Negotiation Extension to allow negotiation of the application protocol over a secure connection.

• JEP 245: Validate JVM Command-Line Flag Arguments

  • Enhances the JVM to validate command-line options and produce clear error messages.

• JEP 246: Leverage CPU Instructions for GHASH and RSA

  • Enhances the JDK to leverage CPU instructions for GHASH and RSA algorithms.

• JEP 247: Compile for Older Platform Versions

  • Enhances the javac compiler to generate class files that will work on specified older versions of the platform.

• JEP 248: Make G1 the Default Garbage Collector

  • Makes G1 the default garbage collector on server configurations.

• JEP 249: OCSP Stapling for TLS

  • Implements OCSP stapling for TLS, improving the performance of the OCSP protocol.

• JEP 250: Store Interned Strings in CDS Archives

  • Enhances the Class Data Sharing (CDS) feature to store interned strings.

• JEP 251: Multi-Resolution Images

  • Adds a new multi-resolution image API.

• JEP 252: Use CLDR Locale Data by Default

  • Changes the default locale data to use the Unicode Consortium's Common Locale Data Repository (CLDR).

• JEP 253: Prepare JavaFX UI Controls & CSS APIs for Modularization

  • Prepares the JavaFX UI controls and CSS APIs for modularization.

• JEP 254: Compact Strings

  • Changes the internal representation of the String class from a UTF-16 char array to a byte array plus an encoding-flag field.

• JEP 255: Merge Selected Xerces 2.11.0 Updates into JAXP

  • Merges selected bug fixes and enhancements from Xerces 2.11.0 into the JDK's implementation of JAXP.

• JEP 256: BeanInfo Annotations

  • Introduces annotations for customizing the behavior of java.beans.Introspector.

• JEP 257: Update JavaFX/Media to Newer Version of GStreamer

  • Updates the JavaFX media stack to a newer version of the GStreamer multimedia framework.

• JEP 258: HarfBuzz Font-Layout Engine

  • Integrates the HarfBuzz open-source text shaping engine into the JDK.

• JEP 259: Stack-Walking API

  • Provides a standard API for stack walking that allows easy filtering of, and lazy access to, stack trace information.

• JEP 260: Encapsulate Most Internal APIs

  • Encapsulates most of the JDK's internal APIs to improve security and maintainability.

• JEP 261: Module System

  • Implements the Java Platform Module System, as specified by JSR 376.

• JEP 262: TIFF Image I/O

  • Adds the TIFF image format to the set of standard image formats supported by the Java Image I/O API.

• JEP 263: HiDPI Graphics on Windows and Linux

  • Adds automatic scaling of JavaFX applications on HiDPI displays on Windows and Linux.

• JEP 264: Platform Logging API and Service

  • Introduces a common logging API for all Java SE and JDK components.

• JEP 265: Marlin Graphics Renderer

  • Replaces Pisces/Stroker as the default graphics rasterizer in JavaFX for improved rendering performance.

• JEP 266: More Concurrency Updates

  • Enhances java.util.concurrent with further asynchronous mechanisms and a new CompletableFuture API.

• JEP 267: Unicode 8.0

  • Updates the existing platform APIs to support Unicode 8.0.

• JEP 268: XML Catalogs

  • Adds support for XML Catalogs, an OASIS standard, to resolve external resources during XML parsing.

• JEP 269: Convenience Factory Methods for Collections

  • Introduces new static factory methods on the List, Set, and Map interfaces to simplify the creation of immutable instances.

• JEP 270: Reserved Stack Areas for Critical Sections

  • Reserves stack space for critical sections to improve system reliability.

• JEP 271: Unified GC Logging

  • Unifies the logging of garbage collection (GC) activities across different GC implementations.

• JEP 272: Platform-Specific Desktop Features

  • Adds new platform-specific desktop features, including support for modern file dialogs on macOS and new native system tray access.

• JEP 273: DRBG-Based SecureRandom Implementations

  • Provides new implementations of java.security.SecureRandom that are based on the NIST-approved DRBG mechanism.

• JEP 274: Enhanced Method Handles

  • Enhances the java.lang.invoke.MethodHandles class to support various method handle transformations which are currently cumbersome to express.

• JEP 275: Modular Java Application Packaging

  • Provides tools for modular Java applications, allowing packaging modules and runtime images into different formats for distribution.

• JEP 276: Dynamic Linking of Language-Defined Object Models

  • Enables efficient and robust linking of high-level object models to the JVM.

• JEP 277: Enhanced Deprecation

  • Enhances the deprecation annotation and provides tools to analyze deprecation impact.

• JEP 278: Additional Tests for Humongous Objects in G1

  • Adds more testing for the handling of humongous objects in the G1 garbage collector.

• JEP 279: Improve Test-Failure Troubleshooting

  • Improves the diagnosability of test failures, making it easier to troubleshoot issues in the JDK test suite.

• JEP 280: Indify String Concatenation

  • Changes the bytecode generation strategy for the String::concat method to improve performance.

• JEP 281: HotSpot C++ Unit-Test Framework

  • Introduces a new unit-test framework for the HotSpot C++ code, aiming to improve code quality and enable better testing.

• JEP 282: jlink: The Java Linker

  • Adds the jlink tool to assemble and optimize a set of modules and their dependencies into a custom runtime image.

• JEP 283: Enable GTK 3 on Linux

  • Adds support for GTK 3 on Linux, enabling modernization of the JavaFX media stack.

• JEP 284: New HotSpot Build System

  • Replaces the HotSpot build system with a new one based on the build-infra project, aiming for improved build performance and maintainability.

• JEP 285: Spin-Wait Hints

  • Introduces an API to allow Java code to hint that a spin loop is being executed, enabling better CPU utilization.

• JEP 287: SHA-3 Hash Algorithms

  • Adds the SHA-3 family of cryptographic hash functions to the java.security.MessageDigest API.

• JEP 288: Disable SHA-1 Certificates

  • Disables SHA-1 certificates for secure socket layer (SSL) and transport layer security (TLS) by default to improve security.

• JEP 289: Deprecate the Applet API

  • Deprecates the Applet API, signaling that it will be removed in a future release.

• JEP 290: Filter Incoming Serialization Data

  • Enhances the serialization mechanism to allow incoming streams of object-serialization data to be filtered.

• JEP 291: Deprecate the Concurrent Mark Sweep (CMS) Garbage Collector

  • Deprecates the CMS garbage collector, signaling that it will be removed in a future release.

• JEP 292: Implement Selected ECMAScript 6 Features in Nashorn

  • Adds new ECMAScript 6 features to the Nashorn JavaScript engine.

• JEP 294: Linux/s390x Port

  • Adds a Linux/s390x port to the JDK.

• JEP 295: Ahead-of-Time Compilation

  • Introduces an experimental ahead-of-time (AOT) compiler to improve the startup time of Java applications.

• JEP 297: Unified arm32/arm64 Port

  • Unifies the source code for the arm32 and arm64 ports into a single forest.

• JEP 298: Remove Demos and Samples

  • Removes the demos and samples from the JDK.

• JEP 299: Reorganize Documentation

  • Reorganizes the documentation to make it easier to find relevant information.

Java JDK 8

There are also a number of JEPs introduced in Java JDK 8 and it's iterations 8u20, 8u40 and 8u60, but they are not included in this list, as this project only aims to cover changes from Java 9 and up.

Refer to JEP Index for the rest of the entries including pending, drafts and rejected.