Java 24 & 25: The Next LTS — Simpler, Faster, Safer

import java.util.stream.Gatherers;

// windowFixed — emit fixed-size non-overlapping windows
Stream.of(1, 2, 3, 4, 5, 6, 7)
    .gather(Gatherers.windowFixed(3))
    .forEach(System.out::println);
// [1, 2, 3]
// [4, 5, 6]
// [7]

// windowSliding — emit sliding windows
Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.windowSliding(3))
    .forEach(System.out::println);
// [1, 2, 3]
// [2, 3, 4]
// [3, 4, 5]

// scan — running accumulation (like reduce but emits each intermediate result)
Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.scan(() -> 0, Integer::sum))
    .forEach(System.out::println);
// 1, 3, 6, 10, 15

// fold — like reduce but always produces a result
Optional<Integer> sum = Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.fold(() -> 0, Integer::sum))
    .findFirst();
// Optional[15]

// mapConcurrent — map with bounded concurrency using virtual threads
Stream.of("url1", "url2", "url3", "url4", "url5")
    .gather(Gatherers.mapConcurrent(3, url -> fetchContent(url)))
    .forEach(System.out::println);

// A custom gatherer that emits elements in pairs with their running total
Gatherer<Integer, ?, String> runningTotalPairs = Gatherer.ofSequential(
    () -> new int[]{0},  // state: running total
    (state, element, downstream) -> {
        state[0] += element;
        return downstream.push(element + " (total: " + state[0] + ")");
    }
);

Stream.of(10, 20, 30, 40)
    .gather(runningTotalPairs)
    .forEach(System.out::println);
// 10 (total: 10)
// 20 (total: 30)
// 30 (total: 60)
// 40 (total: 100)

// Define a scoped value (typically as a static final field)
public class RequestContext {
    public static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();
    public static final ScopedValue<String> REQUEST_ID  = ScopedValue.newInstance();
}

// Bind values for a scope
void handleRequest(HttpRequest request) {
    User user = authenticate(request);
    String requestId = generateId();

    ScopedValue.where(RequestContext.CURRENT_USER, user)
               .where(RequestContext.REQUEST_ID, requestId)
               .run(() -> processRequest(request));
}

// Access from anywhere in the call stack within the scope
void processRequest(HttpRequest request) {
    User user = RequestContext.CURRENT_USER.get();
    String id  = RequestContext.REQUEST_ID.get();
    log.info("[{}] Processing request for {}", id, user.name());
    // ... delegate to service layer, repository, etc.
}

// A complete, runnable Java 25 program
void main() {
    System.out.println("Hello, World!");
}

import module java.base;

void main() {
    var names = List.of("Alice", "Bob", "Charlie");
    names.stream()
         .filter(n -> n.length() > 3)
         .map(String::toUpperCase)
         .forEach(System.out::println);
}

// Before Java 25 — had to use a static helper method
class PositivePoint extends Point {
    PositivePoint(int x, int y) {
        super(validate(x), validate(y)); // only option
    }
    private static int validate(int v) {
        if (v < 0) throw new IllegalArgumentException("Must be positive");
        return v;
    }
}

// Java 25 — code before super() is allowed
class PositivePoint extends Point {
    PositivePoint(int x, int y) {
        // Validation before super() — now legal
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException(
                "Coordinates must be non-negative, got: (%d, %d)".formatted(x, y)
            );
        }
        super(x, y);
    }
}

import module java.base;    // imports all of java.lang, java.util, java.io, etc.
import module java.sql;     // imports java.sql, javax.sql

public class DatabaseExample {
    // No individual imports needed for List, Map, Connection, etc.
    public List<Map<String, Object>> query(Connection conn, String sql) throws SQLException {
        var results = new ArrayList<Map<String, Object>>();
        try (var stmt = conn.prepareStatement(sql);
             var rs   = stmt.executeQuery()) {
            while (rs.next()) {
                var row = new LinkedHashMap<String, Object>();
                for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
                    row.put(rs.getMetaData().getColumnName(i), rs.getObject(i));
                }
                results.add(row);
            }
        }
        return results;
    }
}

// Stable in Java 25
Object obj = 42;

// instanceof with primitive type
if (obj instanceof int i) {
    System.out.println("int: " + i);
}

// switch with primitive types
String classify(Object o) {
    return switch (o) {
        case int i    when i < 0   -> "negative int";
        case int i                 -> "non-negative int";
        case long l                -> "long: " + l;
        case double d              -> "double: " + d;
        case boolean b             -> "boolean: " + b;
        case String s              -> "string: " + s;
        case null                  -> "null";
        default                    -> "other";
    };
}