Java Version History

Why Java's Version History is Practical Knowledge, Not Trivia

Every Java feature was introduced in a specific version, and assuming otherwise is how legacy codebases get broken. Reading an older codebase, planning an upgrade, or copying a modern snippet into an existing project all require knowing exactly which version introduced what — not as historical curiosity, but as a precondition for the code actually compiling.

// BEFORE — assuming a modern feature is universally available
var order = new Order();
// Copied into a Java 8 codebase: compile error. `var` didn't exist until
// Java 10 — the snippet is correct Java, just not correct for THIS codebase.

// AFTER — knowing the version timeline before writing the line
Order order = new Order();
// Explicit type, because this project targets Java 8 — verified against
// the version table below before assuming otherwise.

Understanding Java's Release Model

Since Java 9, a new feature release ships every six months, but only some of those are designated LTS (Long-Term Support) — the ones actually worth deploying to production and staying on for years.

The Foundation Era (1996–2004)

These early releases established Java's core identity — much of what they introduced is still used exactly as originally designed.

Java 1.0 (January 1996) — "Oak"

The first public release, developed under the codename "Oak," introduced "write once, run anywhere": Applets (running Java in a browser), AWT for GUIs, the core java.lang/java.io/java.util classes, automatic garbage collection, and a sandboxed security model for untrusted code.

Java 1.1 (February 1997)

// Inner classes
public class Outer {
    private String message = "Hello";
    class Inner {
        void printMessage() { System.out.println(message); }
    }
}

// JDBC — database connectivity
Connection conn = DriverManager.getConnection(
    "jdbc:mysql://localhost/shop", "user", "pass");

// Reflection
Class<?> clazz = String.class;
Method[] methods = clazz.getMethods();

Java 1.2 (December 1998) — rebranded "Java 2"

// The Collections Framework — still used, structurally, exactly like this
List list = new ArrayList();   // no generics yet — casting required on read
list.add("Hello");
String s = (String) list.get(0);

Java 1.3 (May 2000) — "Kestrel"

HotSpot became the default JVM (a major performance jump), JNDI joined the core platform, plus the Java Sound API and RMI-over-IIOP.

Java 1.4 (February 2002) — "Merlin"

// assert — design by contract
public void setAge(int age) {
    assert age >= 0 : "Age cannot be negative";
}

// Regular expressions, finally
Pattern pattern = Pattern.compile("\\d{3}-\\d{4}");

// Chained exceptions
try { riskyOperation(); }
catch (SQLException e) { throw new DataAccessException("Failed", e); }

The Modern Java Era (2004–2014)

Java 5 through 8 turned a verbose, ceremonial language into a genuinely expressive one.

Java 5 (September 2004) — "Tiger"

// Generics — type safety at compile time
List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123);  // now a compile error, not a runtime ClassCastException

// Enhanced for-loop, autoboxing, enums, varargs, annotations — all Java 5
public enum OrderStatus { PENDING, SHIPPED, DELIVERED }

@Override
public String toString() { return "Order instance"; }

Java 6 (December 2006) — "Mustang"

Focused on performance and tooling rather than language syntax: the Scripting API (JSR 223), a Compiler API, JDBC 4.0 driver auto-loading, and pluggable annotation processing.

Java 7 (July 2011) — "Dolphin"

// Diamond operator
Map<String, List<Integer>> map = new HashMap<>();

// try-with-resources
try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
}   // closed automatically, even on exception

// Multi-catch
try { riskyOperation(); }
catch (IOException | SQLException e) { logger.error("Failed", e); }

Java 8 (March 2014) — the functional revolution

Arguably the most important release since Java 5, and still the most widely deployed version in production today.

// Lambda expressions
Runnable task = () -> System.out.println("Hello!");

// Stream API
List<String> names = customers.stream()
    .filter(c -> c.getAge() >= 18)
    .map(Customer::getName)
    .sorted()
    .collect(Collectors.toList());

// Optional — no more silent NullPointerException
Optional<Customer> customer = customerRepository.findById(id);
String name = customer.map(Customer::getName).orElse("Unknown");

// New Date/Time API — immutable, thread-safe, finally correct
LocalDate today = LocalDate.now();
ZonedDateTime zonedNow = ZonedDateTime.now(ZoneId.of("America/New_York"));

The Rapid Release Era (2017–Present)

Starting with Java 9, Oracle moved to the current 6-month cadence — faster features, more attention required to version management.

Java 9 (September 2017) — the module system

// module-info.java — Project Jigsaw, the biggest structural change since Java's creation
module com.shop.catalog {
    requires java.sql;
    exports com.shop.catalog.api;
    opens com.shop.catalog.internal to com.shop.framework;
}

// Immutable collection factories
List<String> list = List.of("a", "b", "c");

// Private methods in interfaces, JShell (REPL), Stream.takeWhile/dropWhile

Java 10 (March 2018)

// var — local variable type inference
var orders = List.of("a", "b", "c");
// NOT allowed: fields, method parameters, return types — local variables only

Java 11 (September 2018) — LTS

The first LTS under the new model, and still a common production baseline.

// Standard HTTP Client — no more third-party dependency for this
HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_2).build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

// New String methods
"  hello  ".strip();   // "hello" — Unicode-aware, unlike trim()
"hello".repeat(3);

Java 12–16 (2019–2021) — preview features that became Java 17

// Switch expressions (standard in 14)
String result = switch (day) {
    case MONDAY, FRIDAY -> "Work";
    case SATURDAY, SUNDAY -> "Rest";
    default -> "Unknown";
};

// Text blocks (standard in 15)
String json = """
    { "name": "Alice", "age": 30 }
    """;

// Records (standard in 16) — one line instead of a full data class
record Customer(String name, int age) { }

// Pattern matching for instanceof (standard in 16)
if (obj instanceof String s) {
    System.out.println(s.length());   // already cast into s
}

Java 17 (September 2021) — LTS

// Sealed classes — the compiler knows every permitted subtype
sealed interface Shape permits Circle, Rectangle, Triangle { }

// Exhaustive switch over a sealed hierarchy — no default branch needed
double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> 0.5 * t.base() * t.height();
    };
}

Java 21 (September 2023) — LTS

// Virtual threads (Project Loom) — see Application Servers & Deployment for
// the full capacity-planning implications of this
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {
        executor.submit(() -> fetchAndProcess());   // millions of concurrent tasks, cheaply
    }
}

// Record patterns — nested destructuring
record Point(int x, int y) { }
record Line(Point start, Point end) { }

if (obj instanceof Line(Point(var x1, var y1), Point(var x2, var y2))) {
    System.out.println("Line from (" + x1 + "," + y1 + ") to (" + x2 + "," + y2 + ")");
}

// Sequenced Collections — first/last access without index arithmetic
SequencedCollection<String> list = new ArrayList<>();
list.addFirst("first"); list.addLast("last");
SequencedCollection<String> reversed = list.reversed();

Java 22 to Today (2024–2026)

Java 22–24 (2024) — non-LTS, notable groundwork

• The Foreign Function & Memory API reached its final form — the modern, pure-Java replacement for JNI when interoperating with native libraries
• Stream Gatherers — custom intermediate stream operations beyond the built-in set
• Continued preview iterations of Structured Concurrency and Scoped Values

Java 25 (September 2025) — current LTS

// Flexible constructor bodies — validate BEFORE calling super()
class PremiumCustomer extends Customer {
    PremiumCustomer(String name) {
        if (name == null) throw new IllegalArgumentException("Name required");
        super(name);   // previously HAD to be the very first statement — no validation possible before it
    }
}

// Module import declarations — one line instead of a wall of package imports
import module java.base;

// Compact source files and instance main methods — no boilerplate for a script
void main() {
    System.out.println("Hello from Java 25!");
}

// Scoped Values (finalized) — a safer, immutable alternative to ThreadLocal
// for passing context through a call tree, particularly relevant alongside
// virtual threads where thousands of concurrent tasks make mutable
// ThreadLocal state a real correctness risk

Java 25 also finalized Generational Shenandoah and Compact Object Headers (both reducing GC overhead and per-object memory cost), and — a genuinely disruptive removal — dropped 32-bit x86 support entirely; the JDK is now 64-bit only. Oracle committed to at least 5 years of premier support for this LTS.

Java 26 (March 2026) — the current release, non-LTS

Ten JEPs, five finalized. No new stable language syntax this round — the focus is runtime and library work: the Applet API (deprecated for removal since Java 17) is finally gone; the AOT cache introduced under Project Leyden now works with any garbage collector, including ZGC, to reduce startup and warm-up time; and cryptography continues hardening with hybrid public-key encryption and post-quantum-ready JAR signing. Structured Concurrency and Primitive Types in Patterns both continue as previews, still maturing toward a future stable release.

Complete Version Reference

Migration Guide

Java 8 → 11

• Add explicit dependencies for the Java EE modules removed from the JDK itself (JAXB, JAX-WS)
• --add-opens for any illegal reflective access the module system now blocks by default
• Replace javax.xml.bind with jakarta.xml.bind
• Update build tooling (Maven 3.5+, Gradle 5+)

Java 11 → 17

• Strong encapsulation denies illegal reflective access by default — no opt-out flag as a permanent fix, only a deadline extension
• Can adopt records, sealed classes, pattern matching for instanceof
• Some weaker cryptographic algorithms removed — audit TLS/cipher configuration

Java 17 → 21

• Evaluate migrating blocking, thread-per-request code to virtual threads (see Application Servers & Deployment for the full capacity-planning picture)
• Can adopt record patterns and sequenced collections

Java 21 → 25

• If any experimental code used the String Templates preview from 21/22, it must be removed entirely — the feature doesn't exist in 23+
• Verify no dependency targets 32-bit x86 — support was dropped entirely
• Evaluate Scoped Values as a replacement for ThreadLocal in code that also adopted virtual threads

Common Pitfalls

@Deprecated(since = "9", forRemoval = true)
public void oldMethod() { }   // this will actually be removed — not a stylistic suggestion

Interview Questions