Java Version History

JDK Alpha and Beta (1995)

The Java Alpha and Beta was the first releasesbut they have highly unstable APIs and ABIs. The supplied Java web browser was named WebRunner.

The earliest public releases of Java were the JDK Alpha and Beta in 1995. They were unfit for production use due to their extremely unstable ABIs and APIs. These releases also featured WebRunner, a minimal Java web browser that showed off Java's early potential for web development. These releases, in spite of initial shortcomings, set the groundwork for Java's further development and expansion.

JDK 1.0 (January 23, 1996)

It was the first stable released version of Java. Its codename was Oak. The first stable version of JDK was JDK 1.0.2 and it was called Java 1.

Up to JDK 1.0.1, private and protected keywords could be used together to create yet another form of protection which used to act as a restriction to methods or variables mainly to subclasses of a given class. In JDK 1.0.2, this capability has been removed.

JDK 1.1 (February 19, 1997)

Some additions were included to this version. i.e.

• The concept of Inner Class
• JavaBeans
• JDBC
• RMI
• AWT event model was totally reshaped.
• Reflection (which supported Introspection only, modification was not possible at runtime).
• JIT (Just-In-Time) compiler on Microsoft Windows platforms, produced for JavaSoft by Symantec
• Internationalization and Unicode support originating from Taligent.
• Java Foundation Classes (JFC/Swing): The Swing graphical user interface toolkit was introduced.
• JJDK 1.1 introduced the JAR file format, which allowed multiple files to be bundled together into a single archive for easier distribution and deployment of Java applications and libraries.
• JNDI was introduced to provide a unified interface for accessing different naming and directory services, such as LDAP (Lightweight Directory Access Protocol), DNS (Domain Name System), and NIS (Network Information Service).
• JDK 1.1 enhanced the security features of Java by introducing a comprehensive security architecture, including support for digital signatures, certificates, and access control mechanisms.

J2SE 1.2 (December 8, 1998)

Its codename was Playground. The first time, it was called J2SE (Java 2 Platform, Standard Edition). It replaced JDK to recognize the base platform from J2EE (Java 2 Platform, Enterprise Edition) and J2ME (Java 2 Platform, Micro Edition). It was a very important Java release as it tripled the size of the Java platform to 1520 classes in 59 packages.

Some additions were included to this version. i.e.

• Java plug-in.
• Java IDL, an IDL implementation for CORBA interoperability.
• Collections framework.
• The Swing graphical API was integrated into the core classes.
• Sun's JVM was equipped with a JIT compiler for the first time.
• JNDI was further enhanced in J2SE 1.2 to provide better support for directory services and naming systems, making it easier for Java applications to interact with enterprise-level services.
• J2SE 1.2 introduced the Java 2D API, which provided a powerful set of graphics capabilities for rendering 2D shapes, text, and images.
• The Java Sound API was introduced in J2SE 1.2, providing a platform-independent way to work with audio data and devices. This API enabled developers to incorporate audio playback, recording, and processing into their Java applications.
• JNDI was further enhanced in J2SE 1.2 to provide better support for directory services and naming systems, making it easier for Java applications to interact with enterprise-level services.
• JAAS was introduced in J2SE 1.2 to provide a framework for implementing authentication and authorization in Java applications.

J2SE 1.3 (May 8, 2000)

Its codename was Kestrel. Some additions were included to this version. i.e.

• HotSpot JVM included.
• RMI was modified to support optional compatibility with CORBA.
• JNDI (Java Naming and Directory Interface).
• Java Platform Debugger Architecture (JPDA) included.
• JavaSound.
• Synthetic proxy classes.
• Java Cryptography Extension (JCE)

J2SE 1.4 (February 6, 2002)

Its codename was Merlin. It was the first Java platform which was released under the Java Community Process.

Some additions were included to this version. i.e.

• Improved libraries.
• Perl regular expressions included.
• Provided exception chaining (It allows an exception to encapsulate original lower-level exception).
• IPv6 support (Internet Protocol version 6).
• Logging API (Specified in JSR 47.)
• Image I/O API for reading and writing images in formats like JPEG and PNG.
• XML parser and XSLT processor integrated.
• Security and cryptography extensions (JCE, JSSE, JAAS) integrated.
• J2SE 1.4 introduced the NIO API, which provided a more scalable and efficient mechanism for performing I/O operations in Java applications.
• J2SE 1.4 included Java Web Start, a technology that allowed Java applications to be deployed and launched from a web browser or desktop without manual installation.
• J2SE 1.4 introduced the JMX API, which provided a standard way to monitor and manage Java applications and resources.

Support and security updates for Java 1.4 ended in October 2008.

J2SE 5.0 (September 30, 2004)

Its codename was Tiger. It was originally numbered 1.5, which is still used as the internal version number. So, it was changed to 5.0 to "better reflect the level of maturity, stability, scalability and security of the J2SE". This process also was released under the Java Community Process.

Support and security updates for Java 5.0 ended on November 3, 2009 but updates were available to paid Oracle customers until May 2015.

J2SE 5.0 added some significant new language features:

• It provided compile-time (static) type safety for collections and eliminates the need for most typecasts.
• Used Metadata or annotations.
• Autoboxing/unboxing.
• Enumerations.
• Enhanced for each loop.
• Improved semantics of execution for multi-threaded Java programs.
• Static imports.

There were also some improvements in standard libraries:

• Automatic stub generation for RMI objects.
• Swing: It provided a skinny look and feel.
• The concurrency utilities in package java.util.concurrent.
• Scanner class for parsing data from various input streams and buffers.
• Java 5 was the last release of Java that officially supported Microsoft Windows 9x line (Windows 95, Windows 98, Windows ME).
• Windows Vista was the last version of Windows that J2SE 5 supported before going to end in October 2009.
• Generics: J2SE 5.0 introduced generics, allowing developers to write type-safe and more concise code by specifying the types of objects that collections can contain at compile time. This helped improve code clarity, readability, and maintainability.
• Enhanced for Loop (for-each): The enhanced for loop, also known as the for-each loop, provided a simpler and more readable syntax for iterating over collections and arrays. It made code more expressive and reduced the potential for errors in loop constructs.
• Concurrency Utilities: J2SE 5.0 introduced the java.util.concurrent package, providing high-level concurrency utilities such as Executors, ThreadPoolExecutor, and Concurrent collections. These utilities simplified the development of multithreaded applications and improved scalability and performance.
• Swing Look and Feel: J2SE 5.0 provided a new "Ocean" look and feel for Swing components, offering a modern and streamlined appearance that improved the visual appeal of Java GUI applications.

Java 5 was the last release of Java which officially supportedthe Microsoft Windows 9x line (Windows 95, Windows 98, Windows ME).

Windows Vista was the last version of Windows that J2SE 5 supported before going to end in October 2009.

Java 5.0 is the default version of Java installed on Apple Mac OS X 10.5 (Leopard). Java 6 can be installed

Java SE 6 (December 11, 2006)

Its codename was Mustang. After this version's release, Java changed the name from J2SE to Java SE and dropped the .0 (point zero) after the version number.

• Dropped the support for older Win9x versions.
• Scripting Language Support.
• Generic API for tight integration with scripting languages.
• Improved Web Service support.
• JDBC 4.0 support.
• Use a Java Compiler API to invoke a Java Compiler programmatically.
• Java Compiler API Enhancements.
• Java SE 6 introduced official support for 64-bit platforms.
• Java SE 6 included enhancements to desktop integration, providing better support for native look and feel and improved integration with the host operating system's desktop environment.

After the release of Java 6, Sun released many updates to fix bugs.

Java SE 7 (July 28, 2011)

Its codename was Dolphin. It was launched on 7, July 2011 but was made available for developers on July 28, 2011.

Some additions were included to this version. i.e.

• JVM support for dynamic languages.
• Compressed 64-bits pointer.
• Strings added in switch.
• Automatic resource management in try-statement.
• Underscores allowed in numeric literals.
• Binary integer literals.
• Improved type interface for creating generic instance. (also called diamond operator <>)
• Improved catching and throwing. (catch multiple exceptions and rethrow with improved type checking)
• Provided Java Deployment rulesets.
• Along with automatic resource management, Java SE 7 introduced the try-with-resources statement, which simplified resource management by automatically closing resources such as streams and connections at the end of a try block.
• Java SE 7 introduced the Fork/Join framework, which provided support for parallelism and concurrent processing of tasks, particularly useful for implementing divide-and-conquer algorithms.
• Java SE 7 introduced the NIO.2 API, also known as the "JSR 203: More New I/O APIs for the Java Platform," which provided enhanced support for file I/O operations, asynchronous I/O, and file system operations.

It was the default version to download on java.com from April 2012 up to the release of Java 8.

Java SE 8 (March 18, 2014)

Its codename was Spider. Although, codenames have been discontinued, but the codename Spider is common among java developers.

It includes some features which were proposed for Java SE 7 but added in Java SE 8.

• Language-level support for Lambda expressions.
• Allowed developers to embed JavaScript code within applications.
• Annotation of Java Types.
• Provided Date and Time API.
• Repeating Annotations.
• Launching of JavaFX applications.
• Removal of permanent generation.
• Java SE 8 included the Nashorn JavaScript Engine, a modern JavaScript engine for the JVM.

Java SE 8 is not supported in Windows XP but after JDK 8 update 25, we can install and run it under Windows XP.

Java 8 is set as a default version to download from java.com from October 2014.

Java SE 9 (September 21, 2017)

In 2016, Oracle discussed some features to release in Java 9. It was hoped that Java 9 would include better support for multi-gigabyte heaps, better native code integration, a different default garbage collector and a self-tuning JVM. The release of Java 9 was postponed many times and finally it was released on September 21, 2017.

It includes some specific features:

• Modularization of the JDK under Project Jigsaw.
• Provided Money and Currency API.
• Tight integration with JavaFX.
• Java implementation of reactive streams.
• More Concurrency Updates.
• Provided Java Linker.
• Automatic scaling and sizing.
• Java SE 9 introduced a migration path for existing codebases to adopt the module system introduced by Project Jigsaw.
• Java SE 9 included enhancements to the garbage collection system, including improvements to the G1 garbage collector and experimental features such as the Garbage-First (G1) garbage collector.

Java SE 10 (March, 20, 2018)

Java SE 10 was released to remove primitive data types and move towards 64-bit addressable arrays to support large data sets. It was released on 20 March 2018, with twelve new features confirmed. These features are:

• Local-Variable Type Inference
• Experimental Java-Based JIT Compiler This is the integration of the Graal dynamic compiler for the Linux x64 platform
• Application Class-Data Sharing This allows application classes to be placed in the shared archive to reduce startup and footprint for Java applications
• Time-Based Release Versioning
• Parallel Full GC for G1
• Garbage-Collector Interface
• Additional Unicode Language-Tag Extensions
• Root Certificates
• Thread-Local Handshakes
• Heap Allocation on Alternative Memory Devices
• Remove the Native-Header Generation Tool - javah
• Consolidate the JDK Forest into a Single Repository

In order to increase developer productivity and make it easier to create contemporary Java applications, Java SE 10 brought improvements to libraries, APIs, and development tools. Updates to development tools, IDE integrations, and libraries to improve developer experience and expedite the development process were among these advancements.

Java SE 10 was a noteworthy version that brought about a number of upgrades and additions to the Java platform, tackling important demands and difficulties in contemporary software development. With these improvements, Java's standing as a top platform for creating reliable and scalable applications was further cemented. These improvements also targeted to increase developer efficiency, security, performance, and platform compatibility.

Java SE 11 (September, 25, 2018)

Java SE 11, released on September 25, 2018, marked a significant milestone as it was the first Long-Term Support (LTS) version after Java 8. LTS versions receive support and updates for a longer duration, making them suitable for production environments. Java 11 introduced several features and enhancements, including:

• Local-Variable Syntax for Lambda Parameters: This feature allows the var keyword to be used for lambda parameters, enhancing readability and conciseness in lambda expressions.
• HTTP Client (Standard): Java 11 included a new, standardized HTTP client API in the java.net.http package, providing a modern alternative to HttpURLConnection with support for HTTP/2 and WebSocket.
• Flight Recorder: Previously a commercial feature, Flight Recorder was made available in OpenJDK 11.
• Epsilon Garbage Collector: Java 11 introduced a new experimental garbage collector called Epsilon, which is designed for use cases where no memory reclamation is needed, such as performance testing or extremely short-lived applications.
• ZGC (Experimental): The Z Garbage Collector (ZGC), introduced as an experimental feature in Java 11, aims to provide scalable, low-latency garbage collection for large heaps, making it suitable for applications requiring very large memory sizes.

Java SE 12 (March 19, 2019):

• Switch Expressions (Preview): Enhancements to the switch statement to allow it to be used as either a statement or an expression, enabling more concise code and reducing duplication.
• JVM Constants API (Preview): Introduces an API to model nominal descriptions of key class-file and run-time artifacts, improving the efficiency and safety of the JVM.

Java SE 13 (September 17, 2019):

• Text Blocks (Preview): Provides a new language feature for writing multiline string literals more easily, enhancing readability and maintainability of code.
• Switch Expressions (Second Preview): Further enhancements to switch expressions, refining the syntax and improving usability based on feedback from the first preview.

Java SE 14 (March 17, 2020):

• Records (Preview): Introduces a new type of class called a record, which is a compact way of declaring classes that are transparent carriers for immutable data.
• Pattern Matching for instanceof (Preview): Enhances the instanceof operator to allow pattern matching, enabling more concise and expressive code when working with instanceof checks.

Java SE 15 (September 15, 2020):

• Sealed Classes (Preview): Introduces sealed classes and interfaces, providing a way to restrict which other classes or interfaces may extend or implement them for enhanced maintainability and security.
• Text Blocks (Second Preview): Text blocks have been further refined, improving their readability and ease of use for multiline string literals.

Java SE 16 (March 16, 2021):

• Records (Second Preview): Refinements to the records feature introduced in Java SE 14, improving usability and providing more flexibility in working with record classes.
• Pattern Matching for instanceof (Second Preview): Enhancements to pattern matching for instanceof, enabling more advanced pattern matching capabilities and improving the expressiveness of code.

Java SE 17 (September, 17, 2021):

Java SE 17 is one of the latest significant releases, which came out in September 2021. It introduced several features and enhancements aimed at improving developer productivity, performance, and security. Some notable additions in Java SE 17 include:

• Sealed Classes: Sealed classes and interfaces provide a way to restrict which other classes or interfaces may extend or implement them.
• Pattern Matching for switch: Pattern matching for switch statements simplifies code by allowing pattern matching directly in switch expressions.
• Foreign Function and Memory API (Incubator): The Foreign Function and Memory API, introduced as an incubator feature, enables Java programs to interoperate with code and data outside of the Java runtime.
• Deprecation of Applet API: The Applet API, which was used for creating web applets, has been deprecated in Java SE 17.
• Deprecation of RMI Activation: The RMI Activation mechanism, which facilitated the activation of remote objects in Java Remote Method Invocation (RMI), has been deprecated.
• Strong Encapsulation of JDK Internals: Java SE 17 continued the process of strong encapsulation of JDK internals started in earlier releases.
• Sealed Classes: You can limit which other classes or interfaces can extend or implement sealed classes and interfaces.
• Pattern Matching for Switch: By enabling pattern matching directly in switch expressions, pattern matching for switch statements streamlines code.
• Foreign Function and Memory API (Incubator): This feature enables Java programmes to communicate with code and data that are not part of the Java runtime. It was first presented as an incubator.
• Applet API Deprecation: Java SE 17 deprecates the Applet API, which was used to create online applets.
• Deprecation of RMI Activation: Java Remote Method Invocation (RMI) has deprecated the RMI Activation method, which made it easier to activate remote objects.
• Robust JDK Internal Encapsulation.