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 was co-generated by ChatGPT 4.0

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.