Java Platform, Standard Edition (Java SE, formerly J2SE) is a set of software programs, tools and libraries that let you develop and deploy Java applications on desktops and servers. In other words, developers use Java SE to build desktop applications running on Java Virtual Machine (JVM).

You can find below the latest version of Java SE - Java Standard Edition (SE) Development Kit (JDK), Java version history (all versions) as well as important changes, updates and enhancements in each Java SE release.

 

1. What is the latest Java version?

As of September 2024, the latest version of Java is Java 23 or JDK 23 released on September, 17th 2024 (follow this article to check Java version on your computer). JDK 23 is a regular update of Java SE platform. And JDK 21 is currently the latest long-term support release (LTS), replacing JDK 17 which is the previous LTS of the Java SE platform. For more information, you can check release notes of JDK 22.

Currently, Oracle corporation maintains and supports the following Java LTS versions: 11, 17, and 21.

 

2. Java version history

Java has been around nearly 3 decades. From the first version released in 1996 to the latest version JDK 23 available to the public since September 2024, the Java platform has been actively being developed for more than 28 years. Many changes and improvements have been made to the technology over the years. The following table summarizes all versions of Java SE throughout its history, from its early days to the latest.

 

From the table above we can see that the naming and the version number have been changing over times:

• Versions 1.0 and 1.1 are named as JDK (Java Development Kit).
• From versions 1.2 to 1.4, the platform is named as J2SE (Java 2 Standard Edition).
• From versions 1.5, Sun introduces internal and external versions. Internal version is continuous from previous ones (1.5 after 1.4), but the external version has a big jump (5.0 for 1.5). This could make confusion for someone, so keep in mind that version 1.5 and version 5.0 are just two different version names for only one thing.
• From Java 6, the version name is Java SE X.

Major versions were released after every 2 years, however the Java SE 7 took 5 years to be available after its predecessor Java SE 6, and 3 years for Java SE 8 to be available to public afterward.

Since Java SE 10,  new versions will be released very six months.

 

3. Important Changes in Java SE versions

Throughout its long history, Java SE has evolved with many changes and updates that enhance both developer productivity and the performance of Java applications. For your reference, below are the important changes in major releases of the Java SE platform:

 

Java SE 1.0 (1996)

• Initial Release: This was the first official release of the Java platform, introducing the basic elements of the language, including the core APIs, JVM, and the basic tools.

 

Java SE 1.1 (1997)

• Inner Classes: Support for inner classes was added.
• JavaBeans: Introduction of the JavaBeans component architecture.
• JDBC: The first version of Java Database Connectivity (JDBC) API.
• Reflection: Introduced for inspecting classes and interfaces at runtime.
• RMI: Remote Method Invocation (RMI) API was introduced.

 

Java SE 1.2 (1998) (also known as Java 2)

• Collections Framework: A new set of data structures such as List, Set, Map, etc.
• Swing: The introduction of the Swing graphical user interface (GUI) components.
• JIT Compiler: Just-In-Time (JIT) compiler integrated into the JVM for better performance.
• Java Plug-in: Enabled applets to run in web browsers.

 

Java SE 1.3 (2000)

• HotSpot JVM: The HotSpot JVM became the default virtual machine, improving performance.
• Java Sound API: Introduction of audio capabilities.
• RMI over IIOP: Allowed RMI to communicate with CORBA-compliant systems.

 

Java SE 1.4 (2002)

• Assertions: Added support for assertions, a debugging tool.
• NIO (New I/O): Enhanced input/output capabilities with non-blocking I/O.
• Regular Expressions: Built-in support for regular expressions.
• Logging API: Introduced for logging information.
• XML Parsing: The inclusion of APIs for processing XML (SAX, DOM).

 

Java SE 5.0 (2004)

• Generics: Added support for generic types, improving type safety.
• Annotations: Introduced metadata annotations.
• Enhanced for-loop: A new syntax for iterating over collections (for-each loop).
• Autoboxing/Unboxing: Automatic conversion between primitive types and their wrapper classes.
• Enumerations: Introduced the enum type.
• Concurrency Utilities: New API for managing threads and synchronization.

 

Java SE 6 (2006)

• Scripting API: Support for scripting languages like JavaScript.
• Pluggable Annotations: Compiler API for processing annotations.
• Web Services: Improved support for web services and the inclusion of JAXB and JAX-WS APIs.
• Performance Improvements: Various JVM and JIT enhancements.

 

Java SE 7 (2011)

• Project Coin: Small language changes such as the diamond operator, try-with-resources, multi-catch exceptions.
• NIO.2: Enhanced file I/O API, with support for file metadata and symbolic links.
• Fork/Join Framework: A framework for parallel programming.
• Strings in Switch: Strings became a valid argument for switch-case statements.
• Automatic Resource Management: Simplified the management of resources like files and sockets.

 

Java SE 8 (2014)

• Lambda Expressions: Introduced to support functional programming.
• Stream API: A powerful API for processing sequences of elements.
• Optional Class: A container object to avoid NullPointerException.
• Default Methods: Interfaces could now have default method implementations.
• Date and Time API: A new, comprehensive API for date and time management.
• Nashorn JavaScript Engine: Replaced the Rhino engine for JavaScript integration.

 

Java SE 9 (2017)

• Modular System (Project Jigsaw): Introduced the module system, allowing for more modular development and deployment.
• JShell: An interactive Java REPL tool.
• Collection Factory Methods: Simplified creation of immutable lists, sets, and maps.
• Enhanced Process API: Improved handling of system processes.
• Private Interface Methods: Allowed private methods within interfaces.

 

Java SE 10 (2018)

• Local Variable Type Inference: Introduction of the var keyword for local variables.
• G1 Garbage Collector Enhancements: Improved garbage collection performance.
• Time-Based Release Model: Shift to a predictable, time-based release cycle every six months.

 

Java SE 11 (2018)

• LTS (Long-Term Support): Java 11 was designated as an LTS release.
• HTTP Client: New HTTP client API to replace the legacy HttpURLConnection.
• Local-Variable Syntax for Lambda Parameters: Extended the use of var in lambda expressions.
• Removed Modules: Several modules, such as Java EE and CORBA, were removed from the standard distribution.
• Nest-Based Access Control: Simplified access control between nested classes.

 

Java SE 12 (2019)

• Switch Expressions (Preview): Enhanced switch statements to be used as expressions.
• JVM Constants API: Simplified the model for describing key class-file and runtime artifacts.

 

Java SE 13 (2019)

• Text Blocks (Preview): Multi-line string literals, simplifying the creation of strings with multiple lines.
• Dynamic CDS Archives: Reduced startup time and footprint through Class Data Sharing.

 

Java SE 14 (2020)

• Switch Expressions (Standard): Finalized the switch expressions introduced as a preview in Java 12.
• Records (Preview): Introduced a compact syntax for declaring data-carrying classes.
• Pattern Matching for instanceof (Preview): Simplified the pattern matching syntax in instanceof checks.

 

Java SE 15 (2020)

• Text Blocks (Standard): Finalized text blocks for multi-line strings.
• Sealed Classes (Preview): Restricted which classes or interfaces can extend or implement them.
• Hidden Classes: Support for creating classes not discoverable by classpath scanners.

 

Java SE 16 (2021)

• Records (Standard): Finalized records as a feature for simpler data classes.
• Pattern Matching for instanceof (Standard): Finalized pattern matching for the instanceof operator.
• JEP 338: Provided Vector API (Incubator) for expressing vector computations that compile to optimized machine code.

 

Java SE 17 (2021)

• LTS (Long-Term Support): Java 17 became the next LTS release.
• Sealed Classes (Standard): Finalized sealed classes for controlling inheritance.
• Pattern Matching for Switch (Preview): Extends pattern matching to switch statements.
• Foreign Function & Memory API (Incubator): Interacting with non-Java code and memory outside the JVM heap.

 

Java SE 18 (2022)

• Simple Web Server: A command-line tool for starting a minimal HTTP server.
• UTF-8 by Default: UTF-8 became the default charset for Java APIs.
• Pattern Matching for Switch (Second Preview): Continued development of pattern matching for switch.

 

Java SE 19 (2022)

• Virtual Threads (Preview): Lightweight threads for simplifying the writing of concurrent applications.
• Structured Concurrency (Incubator): Introduced a new model for structured concurrency in multithreaded programs.
• Record Patterns (Preview): Added patterns to Record classes for deconstruction.
• Pattern Matching for Switch (Third Preview): Further refinements for pattern matching with switch.

 

Java SE 20 (2023)

• Record Patterns (Second Preview): Continued refinement of record patterns for easier data access.
• Pattern Matching for Switch (Fourth Preview): More improvements and features for pattern matching.
• Foreign Function & Memory API (Second Preview): Further enhancements to interact with native code and memory.

 

Java SE 21 (2023) - Currently the Long Term Support (LTS) release

• Virtual Threads: Lightweight, JVM-managed threads that enhance scalability and efficiency in high-concurrency applications.
• Sequenced Collections: New interfaces for maintaining and manipulating ordered data collections.
• Pattern Matching for Switch: Simplifies conditional logic by extending pattern matching to switch statements.

 

Java SE 22 (2024)

• Finalization of the Foreign Function & Memory API: This feature allows Java programs to interact with native code and memory more safely and efficiently, replacing the older JNI approach.
• String Templates (Second Preview): Enhances string handling by allowing easier and safer embedding of expressions within string literals.
• Structured Concurrency (Second Preview): Improves the management of concurrent tasks, making code more reliable and easier to understand.

 

Java SE 23 (2024)

• Markdown in JavaDoc Comments: JavaDoc now supports Markdown, making documentation easier to write and read.
• Generational Z Garbage Collector (ZGC): JDK 23 makes generational mode the default for ZGC.
• Features still In Preview: Structured Concurrency, Flexible Constructor Bodies, Module Import Declarations, Primitive Types in Patterns, instanceof, and switch.

 

More about Java SE:

To learn more about Java SE, below are some references for you:

• Java SE at a Glance
• Java SE Downloads
• Java SE Documentation
• Java SE Community

 

Related Topics:

• What is Java?
• What is Java SE?
• How to check Java version
• Understand 9 features of Java programming language
• How to write, compile and run a hello world Java program for beginners

 

If you want to dive deep into Java programming and become a software developer, I recommend you to learn this Java course on Udemy.