Java History, Versions and Important Features

Introduction to Java

Java is a versatile, high-level, and object-oriented programming language that was developed by James Gosling and his team at Sun Microsystems in 1995. Known for its slogan “Write Once, Run Anywhere” (WORA), Java enables developers to create platform-independent applications that can run on any system with a Java Virtual Machine (JVM).

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

Key Features of Java

Platform Independence: Java programs are compiled into bytecode, which can be executed on any device with a JVM, making it portable.

Object-Oriented: Java uses an object-oriented programming (OOP) approach, promoting code reusability and modularity.

Secure: With features like no explicit pointer usage and a built-in security manager, Java is well-suited for applications requiring high security.

Robust: Java emphasizes early error detection with strong exception handling and memory management through its garbage collector.

Multithreading: Built-in support for multithreaded programming allows the execution of multiple tasks simultaneously.

Rich API and Libraries: Java offers an extensive standard library covering utilities for data structures, networking, databases, and GUIs.

Applications of Java

Java is widely used across various domains:

Web Development: Frameworks like Spring and Hibernate for robust back-end solutions.

Mobile Applications: The backbone of Android development.

Enterprise Software: Powering large-scale applications in finance, healthcare, and retail.

Big Data and Analytics: Tools like Hadoop and Spark use Java.

Gaming and Embedded Systems: Lightweight, efficient applications for resource-constrained devices.

Why Choose Java?

Java's combination of simplicity, performance, and scalability makes it one of the most popular programming languages globally. Its strong community support, regular updates, and extensive documentation ensure it remains relevant for modern software development.

JAVA Versions, Important Features in each release

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 (January 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. Applets, AWT(Abstract Window Toolkit) for basic GUI, JVM etc.

Java 1.1 (February 1997)

Improved AWT with event delegation model.

JDBC (Java Database Connectivity) introduced.

Inner Classes: Support for inner classes was added.

JavaBeans: Introduction of the JavaBeans component architecture.

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.

"HotSpot" JVM for better performance and Improved security model.

Java 1.3 (May 2000)

HotSpot JVM: The HotSpot JVM became the default virtual machine, improving performance further.

Java Sound API: Introduction of audio capabilities.

RMI over IIOP: Allowed RMI to communicate with CORBA-compliant systems.

Java 1.4 (February 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 with JAXP: The inclusion of APIs for processing XML (SAX, DOM).

Java 5 (1.5) (September 2004)

This is the Major update, also known as "Tiger"

Enhanced for-loop: A new syntax for iterating over collections (for-each loop).

Generics: Added support for generic types, improving type safety.

Annotations: Introduced metadata annotations.

Varargs: variable arguments support in parameters

Autoboxing/Unboxing: Auto conversion between primitive types & their wrapper classes.

Enumerations: Introduced the enum type.

Concurrency Utilities: New API for managing threads and synchronization.

Java 6 (December 2006)

Scripting API: Support for scripting languages like JavaScript using JSR 223.

Pluggable Annotations: Introduction of Java 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. Focus on performance and web services.

Java 7 (July 2011)

This version Known as "Dolphin."

Project Coin: Small language changes such as the diamond operator, try-with-resources, multi-catch exceptions.

Improved NIO (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 8 (March 2014)

A landmark release introducing multiple features

Lambda Expressions: Introduced to support functional programming.

Functional Interfaces:

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.

Annotation on Java Types, Unsigned Integer Arithmetic and Repeating annotations

Java 9 (September 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.

Stream API enhancements.

HTTP/2 client: Support for Http2 client introdced

Enhanced Process API: Improved handling of system processes.

Private Interface Methods: Allowed private methods within interfaces.

Platform and JVM Logging, Process API Updates and Collection API Updates

Multi-release JAR Files, @Deprecated Tag Changes and Stack Walking

Java 10 (March 2018)

Local Variable Type Inference: Introduction of the var keyword for local variables.

G1 Garbage Collector Enhancements: Improved garbage collection performance.Parallel Full GC for G1

Time-Based Release Versioning Model: Shift to a predictable, time-based release cycle every six months.

Application Class Data Sharing and Heap Allocation on Alternative Memory Devices

Consolidate the JDK Forest into a Single Repository

Java 11 (September 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.

Removal of JavaFX from JDK and String API Changes

Launch Single-File Programs Without Compilation

Java 12 (March 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.

Collectors.teeing() in Stream API

Files.mismatch(Path, Path)

Compact Number Formatting and Support for Unicode 11

Java 13 (September 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

Re-implementation of the legacy Socket API.

ZGC: Uncommit Unused Memory

DOM and SAX Factories with Namespace Support

Java 14 (March 2020)

Switch Expressions (Standard): Finalized switch expressions introduced.

Records (Preview): Introduced a compact syntax for declaring data-carrying classes.

Pattern Matching for instanceof (Preview): Simplified the pattern matching syntax in instanceof checks.

JFR (Java Flight Recorder) event streaming.

Packaging Tool

NUMA-Aware Memory Allocation for G1

Non-Volatile Mapped Byte Buffers

Remove the Pack200 Tools and API

Java 15 (September 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.

EdDSA Algorithm

Removed Nashorn JavaScript Engine

Java 16 (March 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.

Enable C++14 Language Features

Migrate from Mercurial to Git

Concurrent Thread-Stack Processing

Unix-Domain Socket Channels

Elastic Metaspace

Java 17 (September 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.

Restore Always-Strict Floating-Point Semantics

Enhanced Pseudo-Random Number Generators

Strongly Encapsulate JDK Internals

Deprecation of the SecurityManager.

Java 18 (March 2022)

Simple Web Server: A command-line tool for starting a minimal HTTP server,Simple web server for prototyping.

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.

Code Snippets in Java API Doc

Reimplement Core Reflection with Method Handles

Internet-Address Resolution SPI

Foreign Function & Memory API

Java 19 (September 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 20 (March 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 (September 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 (March 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 (September 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.

Above article covers major changes introduced in each java release. Thanking you for your time reading this article.

Please follow Rajeshwar Kalakuntla for more content.