On September 16, 2025, Oracle Java 25 (Oracle JDK 25) became available as the latest long-term support (LTS) version of the Java platform.
Java 25 delivers 18 major enhancements (JDK Enhancement Proposals, or JEPs) to make Java more productive, efficient, and ready for modern workloads like AI. It improves developer productivity and boosts the platform’s performance, stability, and security.
Oracle is committed to support Java 25 for at least 8 years. This means free quarterly updates until September 2028, and optional extended support available until at least September 2033 for those who need to stay on Java 25 longer.
Top New Features in Java 25
- AI and Performance Enhancements:
- Structured Concurrency (JEP 505) makes it easier to write and manage parallel threads as a group, which is especially helpful for AI tasks or any application doing work in parallel. This leads to more reliable and simpler multithreading.
- Vector API (JEP 508) allows developers to use SIMD vector instructions for math-heavy operations. This means code that processes lots of data (e.g. machine learning computations) can run significantly faster by utilizing modern CPUs more efficiently.
- Beginner-Friendly Improvements: Java 25 lowers the learning curve for new programmers:
- Compact Source Files & Instance Main (JEP 512) let you write a runnable program without the usual boilerplate public static void main(String[] args) method. Beginners and educators can start with a simple file containing code, making Java more accessible for first-time users or quick scripts.
- Module Import Declarations (JEP 511) simplify working with libraries. Developers can import all packages of a module with one statement, even if their code isn’t modular. This means you don’t need to know a library’s module details to use it, which is great for newcomers and speeds up development with third-party code.
- Other Language Updates: Java 25 includes general improvements that make the language more expressive and safer:
- Pattern Matching for Primitive Types (JEP 507, third preview) – You can use pattern matching (e.g., in instanceof checks or switch statements) with primitive types now. This removes restrictions and lets you write cleaner code when working with numbers and other primitives (useful in data processing and AI logic).
- Flexible Main Constructor Bodies (JEP 513) – Constructors can now perform checks or setup before calling their superclass constructor. This helps ensure object initialization is safer and more reliable, catching issues early in the construction process.
Security, Performance, and Monitoring Upgrades
- Stronger Security Features: Java 25 adds new cryptography tools:
- PEM Encoding API (JEP 470, preview) – Simplifies reading and writing cryptographic keys and certificates in PEM format. This makes it easier to integrate Java with standard security assets (like TLS certificates or keys used by other systems).
- Key Derivation Function API (JEP 510) – Provides built-in support for key derivation algorithms, which is important for emerging post-quantum cryptography. It prepares Java applications to generate and use encryption keys that can resist future quantum attacks.
- Better Performance: Several enhancements improve Java’s speed and efficiency:
- Compact Object Headers (JEP 519) reduce the size of object metadata on 64-bit systems. In large applications, this means a smaller memory footprint and better cache usage, allowing more objects to fit in memory and potentially improving throughput.
- Faster Startup with Ahead-of-Time compilation tweaks – JEP 514 makes it easier to generate ahead-of-time compiled code, and JEP 515 uses pre-collected profile data to jump-start the Just-In-Time (JIT) compiler. In practice, Java applications can start up faster and reach peak performance sooner without manual tuning.
- Improved Monitoring (JFR): Java Flight Recorder (JFR), Java’s built-in profiling and diagnostics tool, gets enhancements that help developers tune applications:
- JFR CPU-Time Profiling (JEP 509, experimental) captures more precise CPU usage information per thread. This helps identify which parts of your code are using the most CPU.
- JFR Cooperative Memory Sampling (JEP 518) and JFR Method Tracing (JEP 520) provide more reliable stack sampling and detailed method call timing. This makes it easier to find performance bottlenecks and debug issues, with minimal overhead on the running application.
Java 25 on Oracle Cloud Infrastructure (OCI)
- Immediate Cloud Support: Oracle Cloud Infrastructure was the first hyperscale cloud platform to support Java 25 at launch. If you run your applications on OCI, you could adopt Java 25 right away, ensuring access to the latest features without delay.
- Performance Boosts Included: On OCI, Oracle provides the Java SE Subscription Enterprise Performance Pack at no extra charge for Java 25 deployments. This means Java 25 applications on OCI automatically get performance optimizations (improved JVM tuning and features) to run faster and more efficiently, without additional licensing costs.
- Integrated Support and Management: Oracle’s Java SE Universal Subscription benefits are built into OCI for Java 25 users. This subscription includes professional support, the Java Management Service, and flexible upgrade rights. In short, running Java 25 on OCI gives you enterprise support and tooling out-of-the-box. This helps your team monitor Java apps and apply updates or upgrades on your own schedule with Oracle’s backing.
Ready to get started with Java?
Contact us for a quote.
