Master Java 8‑24: Essential Features, Code Samples & Modern Practices

Java 8 – Core Language Enhancements

Java 8 introduced lambda expressions, functional interfaces, the Stream API, Optional, and a new date‑time API. Lambda expressions replace verbose anonymous inner classes, enabling concise functional programming. Functional interfaces such as Predicate, Function, Consumer, and BinaryOperator provide reusable contracts for lambda usage.

// Lambda example before Java 8
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked");
    }
});

// Java 8 lambda
button.addActionListener(e -> System.out.println("Button clicked"));

The Stream API enables fluent, lazy processing of collections with intermediate operations ( filter, map, sorted) and terminal operations ( collect, forEach, count). Example:

List<String> result = words.stream()
    .filter(w -> w.length() > 5)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

Optional helps avoid NullPointerException by providing methods such as ifPresent, orElse, and orElseThrow.

Java 9 – Module System and New APIs

Java 9 introduced the module system ( module-info.java) for strong encapsulation and explicit dependencies. It also added JShell for interactive exploration and collection factory methods ( List.of, Set.of, Map.of) for immutable collections.

Java 10 – Local‑Variable Type Inference

The var keyword enables type inference for local variables, reducing boilerplate in generic code.

Java 11 – HTTP Client and New String/Files APIs

Java 11 standardized the HTTP client API, supporting synchronous and asynchronous requests, HTTP/2, and WebSocket. New String methods ( isBlank, strip, repeat, lines) simplify text handling. The Files class now offers writeString and readString for one‑line file I/O.

Java 12‑13 – Preview Features

Preview features such as switch expressions and text blocks were introduced, later becoming standard.

Java 14 – Switch Expressions and Null‑Pointer Improvements

Switch expressions allow arrow syntax, multiple case labels, and yield for returning values. The JVM now provides detailed NullPointerException messages indicating the exact null dereference.

Java 15 – Text Blocks and Hidden Classes

Text blocks ( """ … """) enable multi‑line string literals without escaping. Hidden classes improve performance for frameworks that generate short‑lived classes (e.g., lambdas, proxies).

Java 16 – Records and Pattern Matching for instanceof

Records provide a compact syntax for immutable data carriers, automatically generating constructors, accessors, equals, hashCode, and toString. Pattern matching for instanceof allows type checks and variable binding in a single step.

Java 17 – Sealed Classes, New Random Generator, and Strong JDK Encapsulation

Sealed classes restrict which classes may extend them ( permits) and require explicit inheritance strategies ( final, sealed, non‑sealed). A new RandomGenerator API offers multiple algorithms. Access to internal JDK APIs such as sun.misc.Unsafe is now strongly encapsulated.

Java 18 – Simple Web Server, UTF‑8 Default Charset, and JavaDoc Snippets

A built‑in simple web server ( jwebserver) aids development and testing. UTF‑8 becomes the default charset, eliminating platform‑dependent encoding bugs. The @snippet tag enriches JavaDoc with inline code examples.

Java 19‑20 – Preparations for Virtual Threads and Pattern Matching

These releases preview virtual threads, record patterns, and enhanced switch pattern matching, laying groundwork for high‑throughput concurrency.

Java 21 – Virtual Threads, Switch Pattern Matching, Record Patterns, Ordered Collections, and Generational ZGC

Virtual threads provide lightweight, carrier‑thread‑like concurrency, allowing millions of concurrent tasks with minimal OS resources. Switch pattern matching combines type checks with when guards for concise branching. Record patterns enable deconstruction of records directly in switch. New ordered collection methods ( addFirst, addLast, getFirst, removeLast, reversed) simplify head/tail operations. ZGC now uses a generational mode by default, improving pause times for allocation‑heavy workloads.

Java 22 – Foreign Function & Memory API and Unnamed Variables

The Foreign Function & Memory (FFM) API replaces JNI with a safer, type‑checked way to call native code. Underscore ( _) can be used as an unnamed variable in pattern matching and catch clauses, clarifying intent when a value is ignored.

Java 23 – ZGC Generational Mode Becomes Default

Generational ZGC is now the default behavior, delivering lower latency for most applications without extra JVM flags.

Java 24 – Class‑File API and Stream Gatherers

The new class‑file API allows programmatic creation, inspection, and modification of bytecode without third‑party libraries. Stream Gatherers extend the Stream API with stateful collectors such as sliding windows ( Gatherers.windowSliding) and custom gatherers for complex aggregation.

// Example: sliding window average using Gatherers
List<Double> movingAverages = prices.stream()
    .gather(Gatherers.windowSliding(3))
    .map(window -> window.stream().mapToDouble(Double::doubleValue).average().orElse(0.0))
    .collect(Collectors.toList());

These features collectively illustrate Java’s evolution from a classic object‑oriented language to a modern platform supporting functional programming, high‑performance concurrency, and expressive APIs.