Evolution of Java language v1–v25: key features

Legend

— Production (can be used in production)
⚠️ — Preview / Incubator (experimental, not for production, version when it became Production is indicated in parentheses)

Version Table

Version
Main Innovations
Comment / Value
Super Solution (%)
Java 1.0 (1996)
- Basic syntax ✅
- Standard library ✅
The first version of Java, the foundation of the entire language, creating cross-platform applications
20
Java 1.1 (1997)
- Inner classes ✅
- JavaBeans ✅
- JDBC API ✅
Simplification of application architecture, database connectivity
30
Java 1.2 (1998)
- Swing GUI ✅
- Collections Framework ✅
- JIT compilation improved ✅
A big step for desktop applications, convenient work with collections
40
Java 1.3 (2000)
- HotSpot improvements ✅
- Java Sound API ✅
- JNDI ✅
Optimization of the JVM, new APIs for multimedia and networking
45
Java 1.4 (2002)
- assert ✅
- Logging API ✅
- NIO (New IO) ✅
Convenient tools for debugging, new input-output capabilities
50
Java 5 (2004)
- Generics ✅
- Enum ✅
- Annotations ✅
- Enhanced for-loop ✅
- Varargs ✅
The first syntactical revolution, reducing boilerplate, new types and constructs
50
Java 6 (2006)
- Scripting API ✅
- JDBC 4.0 ✅
- JVM improvements ✅
Minor improvements in the platform and performance, integration with scripts
55
Java 7 (2011)
- try-with-resources ✅
- Diamond operator ✅ (new HashMap<💎>();)
- NIO2 ✅
- Fork/Join framework ✅
Major improvements in syntax and parallelism, convenient resource management
60
Java 8 (2014, LTS)
- Lambda expressions ✅
- Stream API ✅
- java.time ✅
- default methods in interfaces ✅
- Optional ✅
- CompletableFuture ✅
The first major functional revolution, simplifying collection handling, introducing a functional style
90
Java 9 (2017)
- Module System (Jigsaw) ✅
- JShell (REPL) ✅ interactive environment for Java
- Improvements to Stream API ✅ A java.util.concurrent.Flow package appeared, 4 basic interfaces (Publisher, Subscriber, Subscription, Processor).
Allows for the creation of modular applications, easing the maintenance of large projects
70
Java 10 (2018)
- Local-Variable Type Inference (`var`) ✅
- GC improvements ✅
Reduces boilerplate code, minor JVM optimizations
50
Java 11 (2018, LTS)
- New HTTP Client ✅
- Single file programs ✅
- Removal of Java EE / CORBA ✅
Simplifies network requests and microservice development, simplifies distribution
60
Java 12 (2019)
- Switch Expressions ⚠️ (Production with Java 14)
- JVM Constants API ✅
- Shenandoah GC (experimental) ⚠️ (Production with Java 15)
The new switch syntax simplifies code, testing new GCs
50
Java 13 (2019)
- Text Blocks ⚠️ (Production with Java 15)
- Dynamic CDS Archives ✅
Convenient creation of multi-line text, faster JVM startup
55
Java 14 (2020)
- Records ⚠️ (Production with Java 16)
- Pattern Matching instanceof ⚠️ (Production with Java 16)
- NVM API ⚠️
Compact immutable classes, simplifies type checking
75
Java 15 (2020)
- Sealed Classes ⚠️ (Production with Java 17)
- Hidden Classes ✅
- Text Blocks stabilized ✅
Control over inheritance, simplification of frameworks
65
Java 16 (2021)
- Records and Pattern Matching confirmed ✅
- Vector API ⚠️ (Production with Java 17)
- jpackage ✅
SIMD-vector optimizations, simplification of native package builds
70
Java 17 (2021, LTS)
- Sealed Classes finalized ✅
- ZGC/G1 improvements ✅
- Foreign Function & Memory API ⚠️ (Production with Java 25)
New GCs and safe handling of external libraries and memory
80
Java 18 (2022)
- Simple Web Server ✅
- UTF-8 by default ✅
- Pattern Matching switch ⚠️ (Production with Java 21)
Fast development and testing, simplifying text work
55
Java 19 (2022)
- Virtual Threads ⚠️ (Production with Java 21)
- Structured Concurrency API ⚠️ (Production with Java 25)
- Record Patterns ⚠️ (Production with Java 21)
A key step towards safe high-concurrency processing
95
Java 20 (2023)
- Scoped Values ⚠️ (Production with Java 25)
- Pattern Matching extended ✅
- Virtual Threads stabilize ⚠️ (Production with Java 21)
Safe state propagation across threads
90
Java 21 (2023, LTS)
- Virtual Threads finalized ✅
- Record Patterns & Pattern Matching extended ✅
- Sequenced Collections API ✅ -- SequencedMap / SequencedSet
Massive simplification of multithreading, improvements in collections and syntax
100
Java 22–24 (2024-2025, non-LTS)
- Foreign Function & Memory API improved ✅
- New GCs and performance ✅
- Structured Concurrency extensions ⚠️ (Production with Java 25)
Direct access to native libraries, JVM optimization
85
Java 25 (2025)
- Loom & Project Panama improved ✅
- Virtual Threads and Structured Concurrency production ✅
- New async APIs ✅
Full safe high-performance multithreading and interaction with native systems
95

Sealed Classes


// Parent class
public sealed class Shape permits Circle, Rectangle { }

// Allowed subclasses
public final class Circle extends Shape { }
public final class Rectangle extends Shape { }

Text Blocks

String json = """
    {
        "name": "Alice",
        "age": 30
    }
    """;
System.out.println(json)

Scoped Values


try (var scope = ScopedValue.where("user", "Alice")) {
    new Thread(() -> {
        System.out.println(ScopedValue.get("user")); // Alice — inherited
    }).start();
} // scope closes, value disappears

Record Pattern


Object obj = new PersonRecord("Alice", 30);

if (obj instanceof PersonRecord(String name, int age)) {
    System.out.println(name + " " + age); // unpacked immediately
}

Pattern Matching for switch


switch (obj) {
    case PersonRecord(String n, int a) when a >= 18 -> System.out.println(n + " is adult");
    case PersonRecord(String n, int a) -> System.out.println(n + " is minor");
    default -> System.out.println("Unknown");
}

Project Panama


import java.foreign.*;

CLinker linker = CLinker.systemCLinker();
Symbol lookup = linker.lookup("printf");
//You can directly call printf from C without JNI templates.
// supported C, C++, Rust, Fortran, Assembler (via C ABI)

Test - Check your knowledge about which version of Java introduced key features and changes.


🌐 На русском
Total Likes:0

Оставить комментарий

My social media channel
By sending an email, you agree to the terms of the privacy policy

Useful Articles:

How to keep a legacy project from dying and give it another 10 years
Signs of a legacy project: how to recognize an old ship A legacy is not just old code. It is a living organism that has survived dozens of changes, team shifts, outdated technologies, and numerous tem...
Reflection on why the completeness of knowledge is unattainable and how to build a personal architecture of professional growth. Every developer has at least once thought: “How to keep up with ev...
Data types in Java
Data Types in Java Hello! This is Vitaly Lesnykh. In this lesson of the "Java Basics for Beginners" course, we will discuss what data types are. Data types are the foundation of any programming langu...

New Articles:

Zero Allocation in Java: what it is and why it matters
Zero Allocation — is an approach to writing code in which no unnecessary objects are created in heap memory during runtime. The main idea: fewer objects → less GC → higher stability and performance. ...
Stream vs For in Java: how to write the fastest code possible
In Java, performance is often determined not by the "beauty of the code," but by how it interacts with memory, the JIT compiler, and CPU cache. Let s analyze why the usual for is often faster than Str...
Compiler, Build, and Tooling in Go and Java: how assembly, initialization, analysis, and diagnostics are organized in two ecosystems
This article is dedicated to a general overview of how the compiler, build, and tooling practices are arranged in Go, and how to better understand them through comparison with Java. We will not delve ...
Fullscreen image