Java 25 Other Improvements

// BEFORE: Traditional switch with if-else for range checks
public String getTemperatureCategory(int tempFahrenheit) {
    if (tempFahrenheit < 0) {
        return "Extreme cold";
    } else if (tempFahrenheit < 32) {
        return "Freezing";
    } else if (tempFahrenheit < 60) {
        return "Cold";
    } else if (tempFahrenheit < 80) {
        return "Comfortable";
    } else if (tempFahrenheit < 100) {
        return "Hot";
    } else {
        return "Extreme heat";
    }
}

// AFTER: Primitive patterns with guards in switch (Java 25)
public String getTemperatureCategory(int tempFahrenheit) {
    return switch (tempFahrenheit) {
        case int t when t < 0   -> "Extreme cold";
        case int t when t < 32  -> "Freezing";
        case int t when t < 60  -> "Cold";
        case int t when t < 80  -> "Comfortable";
        case int t when t < 100 -> "Hot";
        default                 -> "Extreme heat";
    };
}

// Safe narrowing conversion with instanceof
public void processNumber(long value) {
    if (value instanceof int i) {
        // Safe: value fits in an int
        System.out.println("Fits in int: " + i);
        processAsInt(i);
    } else {
        // Value is too large for int
        System.out.println("Needs long: " + value);
        processAsLong(value);
    }
}

// Example calls:
processNumber(42L);           // Fits in int: 42
processNumber(3_000_000_000L); // Needs long: 3000000000

// BEFORE: Manual range checking for narrowing
public void processNumber(long value) {
    if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) {
        int i = (int) value;
        processAsInt(i);
    } else {
        processAsLong(value);
    }
}

// AFTER: Primitive instanceof handles the range check for you
public void processNumber(long value) {
    if (value instanceof int i) {
        processAsInt(i);
    } else {
        processAsLong(value);
    }
}

record Temperature(double value, String unit) {}

record WeatherReading(Temperature temp, int humidity, long timestamp) {}

public String describeWeather(WeatherReading reading) {
    return switch (reading) {
        case WeatherReading(Temperature(double v, String u), int h, long ts)
            when v > 100.0 && u.equals("F") ->
                "Dangerously hot! Temperature: " + v + "°F, Humidity: " + h + "%";

        case WeatherReading(Temperature(double v, String u), int h, long ts)
            when h > 90 ->
                "Very humid! Humidity at " + h + "%, Temp: " + v + "°" + u;

        case WeatherReading(Temperature t, int h, long ts) ->
                "Normal: " + t.value() + "°" + t.unit() + ", Humidity: " + h + "%";
    };
}

// boolean is naturally exhaustive
public String boolSwitch(boolean flag) {
    return switch (flag) {
        case true  -> "Enabled";
        case false -> "Disabled";
        // No default needed -- all boolean values are covered
    };
}

// For int/long/double, you need a default or catch-all pattern
public String intCategory(int value) {
    return switch (value) {
        case 0         -> "Zero";
        case int i when i > 0 -> "Positive: " + i;
        case int i     -> "Negative: " + i;
        // Exhaustive: covers 0, positive, and everything else (negative)
    };
}

// Approach 1: Not thread-safe
public class ConnectionPool {
    private DataSource dataSource;

    public DataSource getDataSource() {
        if (dataSource == null) {
            // Race condition: two threads can both see null
            // and create two DataSource instances
            dataSource = createDataSource();
        }
        return dataSource;
    }
}

// Approach 2: Thread-safe but slow
public class ConnectionPool {
    private DataSource dataSource;

    public synchronized DataSource getDataSource() {
        if (dataSource == null) {
            dataSource = createDataSource();
        }
        return dataSource;
        // Problem: synchronized on every access, even after initialization
    }
}

// Approach 3: Double-checked locking (correct but complex)
public class ConnectionPool {
    private volatile DataSource dataSource;

    public DataSource getDataSource() {
        DataSource result = dataSource;
        if (result == null) {
            synchronized (this) {
                result = dataSource;
                if (result == null) {
                    dataSource = result = createDataSource();
                }
            }
        }
        return result;
        // Correct, but verbose and easy to get wrong
    }
}

// Java 25 Preview: StableValue for lazy initialization
import java.lang.StableValue;

public class ConnectionPool {

    // Lazy, thread-safe, optimal performance after initialization
    private final StableValue dataSource =
        StableValue.of(() -> createDataSource());

    public DataSource getDataSource() {
        return dataSource.get();
    }

    private DataSource createDataSource() {
        System.out.println("Creating DataSource (expensive operation)...");
        // ... setup connection pool
        return new HikariDataSource(config);
    }
}

// Stable list: each element is lazily initialized independently
private final List loggers = StableValue.list(10, i ->
    Logger.getLogger("module-" + i)
);

// Accessing loggers.get(3) only initializes the logger at index 3
// Other loggers remain uninitialized until accessed

// Stable map: each value is lazily initialized by key
private final Map configs = StableValue.map(
    Set.of("database", "cache", "messaging"),
    key -> loadConfiguration(key)
);

// Accessing configs.get("database") only loads the database config
// Other configs remain uninitialized until accessed

// BEFORE: Unstructured concurrency -- error-prone
public UserProfile loadUserProfile(long userId) throws Exception {
    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

    Future userFuture = executor.submit(() -> fetchUser(userId));
    Future> ordersFuture = executor.submit(() -> fetchOrders(userId));
    Future prefsFuture = executor.submit(() -> fetchPreferences(userId));

    // Problem 1: If fetchOrders() fails, fetchUser() and fetchPreferences()
    // keep running even though the result is useless

    // Problem 2: If this thread is interrupted, the futures are orphaned

    // Problem 3: Exception handling is scattered and complex
    try {
        User user = userFuture.get(5, TimeUnit.SECONDS);
        List orders = ordersFuture.get(5, TimeUnit.SECONDS);
        Preferences prefs = prefsFuture.get(5, TimeUnit.SECONDS);
        return new UserProfile(user, orders, prefs);
    } catch (ExecutionException e) {
        // Which task failed? Hard to tell without checking each one.
        throw new RuntimeException("Failed to load profile", e);
    } finally {
        executor.shutdown(); // Easy to forget
    }
}

// AFTER: Structured concurrency -- clean and safe
import java.util.concurrent.StructuredTaskScope;

public UserProfile loadUserProfile(long userId) throws Exception {
    try (var scope = StructuredTaskScope.open()) {

        // Fork concurrent tasks within the scope
        var userTask  = scope.fork(() -> fetchUser(userId));
        var ordersTask = scope.fork(() -> fetchOrders(userId));
        var prefsTask  = scope.fork(() -> fetchPreferences(userId));

        // Wait for all tasks to complete
        scope.join();

        // Get results -- all tasks are guaranteed complete
        return new UserProfile(
            userTask.get(),
            ordersTask.get(),
            prefsTask.get()
        );
    }
    // Scope is closed: all tasks are done, no thread leaks
}

// Strategy 1: Wait for all tasks, throw on any failure (default)
try (var scope = StructuredTaskScope.open()) {
    var task1 = scope.fork(() -> fetchFromServiceA());
    var task2 = scope.fork(() -> fetchFromServiceB());
    scope.join();
    // Both tasks must succeed
    return combine(task1.get(), task2.get());
}

// Strategy 2: Return first successful result, cancel the rest
try (var scope = StructuredTaskScope.open(
        StructuredTaskScope.Joiner.anySuccessfulResultOrThrow())) {
    scope.fork(() -> fetchFromPrimary());
    scope.fork(() -> fetchFromFallback());
    scope.fork(() -> fetchFromCache());
    // Returns the first successful result; cancels slower tasks
    return scope.join();
}

// Strategy 3: Collect all results (including failures)
try (var scope = StructuredTaskScope.open(
        StructuredTaskScope.Joiner.allSuccessfulOrThrow())) {
    scope.fork(() -> validateAddress(address));
    scope.fork(() -> checkCreditScore(userId));
    scope.fork(() -> verifyIdentity(userId));
    // All must succeed; returns all results
    return scope.join();
}

// ThreadLocal problems:

// 1. Mutable -- can be changed at any time from anywhere
private static final ThreadLocal REQUEST_ID = new ThreadLocal<>();

public void handleRequest(String requestId) {
    REQUEST_ID.set(requestId);
    processRequest();
    REQUEST_ID.remove(); // Easy to forget -> memory leak!
}

// 2. Unbounded lifetime -- lives as long as the thread lives
// With thread pools, values persist across unrelated requests

// 3. Expensive with virtual threads -- each virtual thread
// gets its own copy, and there can be millions of them

// 4. Inheritance is broken -- InheritableThreadLocal copies values
// to child threads, but there is no way to scope the lifetime

// Java 25: ScopedValue -- immutable, bounded lifetime, inherited by child threads
import java.lang.ScopedValue;

private static final ScopedValue REQUEST_ID = ScopedValue.newInstance();

public void handleRequest(String requestId) {
    ScopedValue.runWhere(REQUEST_ID, requestId, () -> {
        // REQUEST_ID is bound to requestId within this scope
        processRequest();
        // After this block, the binding is automatically removed
        // No cleanup needed, no memory leaks possible
    });
}

private void processRequest() {
    // Access the scoped value anywhere in the call chain
    String id = REQUEST_ID.get();
    System.out.println("Processing request: " + id);
    callDatabaseLayer();
}

private void callDatabaseLayer() {
    // Still accessible -- inherited through the call chain
    String id = REQUEST_ID.get();
    System.out.println("DB query for request: " + id);
}

private static final ScopedValue USER_CTX = ScopedValue.newInstance();

public void handleApiRequest(UserContext ctx) {
    ScopedValue.runWhere(USER_CTX, ctx, () -> {
        try (var scope = StructuredTaskScope.open()) {
            // Both tasks automatically inherit USER_CTX
            var audit = scope.fork(() -> {
                // USER_CTX.get() works here -- inherited from parent
                logAuditEvent("action started", USER_CTX.get().userId());
                return true;
            });

            var result = scope.fork(() -> {
                // USER_CTX.get() works here too
                return processForUser(USER_CTX.get());
            });

            scope.join();
        }
    });
}

import java.lang.classfile.*;

// Read and inspect a class file
public void inspectClass(Path classFile) throws IOException {
    ClassModel cm = ClassFile.of().parse(classFile);

    System.out.println("Class: " + cm.thisClass().asInternalName());
    System.out.println("Version: " + cm.majorVersion() + "." + cm.minorVersion());
    System.out.println("Flags: " + cm.flags().flagsMask());

    // List all methods
    System.out.println("\nMethods:");
    for (MethodModel method : cm.methods()) {
        System.out.printf("  %s %s%n",
            method.methodName().stringValue(),
            method.methodType().stringValue());
    }

    // List all fields
    System.out.println("\nFields:");
    for (FieldModel field : cm.fields()) {
        System.out.printf("  %s %s%n",
            field.fieldName().stringValue(),
            field.fieldType().stringValue());
    }
}

// Add logging to every method entry
public byte[] addMethodLogging(byte[] classBytes) {
    ClassFile cf = ClassFile.of();
    return cf.transformClass(cf.parse(classBytes), (builder, element) -> {
        if (element instanceof MethodModel method) {
            // Transform each method to add entry logging
            builder.transformMethod(method, (mb, me) -> {
                if (me instanceof CodeModel code) {
                    mb.withCode(cb -> {
                        // Add: System.out.println("Entering: " + methodName)
                        cb.getstatic(ClassDesc.of("java.lang.System"), "out",
                            ClassDesc.of("java.io.PrintStream"));
                        cb.ldc("Entering: " + method.methodName().stringValue());
                        cb.invokevirtual(ClassDesc.of("java.io.PrintStream"),
                            "println",
                            MethodTypeDesc.of(ClassDesc.ofVoid(),
                                ClassDesc.of("java.lang.String")));

                        // Then include the original code
                        code.forEach(cb::with);
                    });
                } else {
                    mb.with(me);
                }
            });
        } else {
            builder.with(element);
        }
    });
}

// Step 1: Training run -- record class loading behavior
// $ java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconf -jar myapp.jar

// Step 2: Generate the AOT cache
// $ java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconf -XX:AOTCache=app.aot -jar myapp.jar

// Step 3: Production run -- use the AOT cache
// $ java -XX:AOTCache=app.aot -jar myapp.jar

// Result: Significantly faster startup time

// Dockerfile with AOT cache generation
// FROM eclipse-temurin:25-jre AS builder
// COPY target/myapp.jar /app/myapp.jar
// WORKDIR /app
//
// # Training run
// RUN java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconf \
//     -jar myapp.jar --spring.profiles.active=aot-training &
//     sleep 10 && kill %1
//
// # Generate cache
// RUN java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconf \
//     -XX:AOTCache=app.aot -jar myapp.jar
//
// FROM eclipse-temurin:25-jre
// COPY --from=builder /app/myapp.jar /app/myapp.jar
// COPY --from=builder /app/app.aot /app/app.aot
// CMD ["java", "-XX:AOTCache=/app/app.aot", "-jar", "/app/myapp.jar"]

// Traditional scalar loop -- processes one element at a time
public float[] scalarMultiply(float[] a, float[] b) {
    float[] result = new float[a.length];
    for (int i = 0; i < a.length; i++) {
        result[i] = a[i] * b[i]; // One multiplication per iteration
    }
    return result;
}

// Vector API -- processes multiple elements per iteration
import jdk.incubator.vector.*;

public float[] vectorMultiply(float[] a, float[] b) {
    var species = FloatVector.SPECIES_256; // 256-bit vectors (8 floats)
    float[] result = new float[a.length];

    int i = 0;
    for (; i < species.loopBound(a.length); i += species.length()) {
        var va = FloatVector.fromArray(species, a, i);
        var vb = FloatVector.fromArray(species, b, i);
        var vr = va.mul(vb); // 8 multiplications in one instruction
        vr.intoArray(result, i);
    }
    // Handle remaining elements
    for (; i < a.length; i++) {
        result[i] = a[i] * b[i];
    }
    return result;
}

// BEFORE: Had to use static helper methods or factory methods
public class PositiveRange {
    private final int low;
    private final int high;

    public PositiveRange(int low, int high) {
        // Could NOT put validation before super() call
        super(); // Must be first statement
        if (low < 0 || high < 0) throw new IllegalArgumentException("Must be positive");
        if (low > high) throw new IllegalArgumentException("low must be <= high");
        this.low = low;
        this.high = high;
    }
}

// AFTER: Statements allowed before super()/this()
public class PositiveRange {
    private final int low;
    private final int high;

    public PositiveRange(int low, int high) {
        // Validation BEFORE calling super -- now legal in Java 25
        if (low < 0 || high < 0) throw new IllegalArgumentException("Must be positive");
        if (low > high) throw new IllegalArgumentException("low must be <= high");
        super();
        this.low = low;
        this.high = high;
    }
}

import javax.crypto.KDF;

// Derive an encryption key using HKDF
KDF hkdf = KDF.getInstance("HKDF-SHA256");
SecretKey derived = hkdf.deriveKey("AES",
    KDF.HKDFParameterSpec.ofExtract()
        .addIKM(inputKeyMaterial)
        .addSalt(salt)
        .thenExpand(info, 32)
        .build());
// Use the derived key for AES encryption

---