Java 23

# Before (Java 22): Non-generational by default
java -XX:+UseZGC MyApp

# After (Java 23): Generational by default
java -XX:+UseZGC MyApp  # Uses generational ZGC

# Opt-out to non-generational
java -XX:+UseZGC -XX:-ZGenerational MyApp

/**
 * Computes the sum of two numbers.
 * <p>
 * <b>Example:</b>
 * <pre>{@code
 * int result = add(2, 3); // returns 5
 * }</pre>
 *
 * @param a the first number
 * @param b the second number
 * @return the sum of a and b
 */
public int add(int a, int b) {
    return a + b;
}

/// Computes the sum of two numbers.
///
/// **Example:**
/// ```java
/// int result = add(2, 3); // returns 5
/// ```
///
/// @param a the first number
/// @param b the second number
/// @return the sum of a and b
public int add(int a, int b) {
    return a + b;
}

/**
 * Traditional JavaDoc comment (HTML)
 */

///
/// Markdown comment (Markdown syntax)
///

static void printType(Object obj) {
    switch (obj) {
        case Integer i -> System.out.println("Integer: " + i);
        case Long l -> System.out.println("Long: " + l);
        case int i -> System.out.println("int: " + i);  // ✨ NEW: primitive
        case long l -> System.out.println("long: " + l); // ✨ NEW: primitive
        case String s -> System.out.println("String: " + s);
        default -> System.out.println("Unknown");
    }
}

static void process(Number num) {
    switch (num) {
        case byte b -> System.out.println("byte: " + b);
        case short s -> System.out.println("short: " + s);
        case int i -> System.out.println("int: " + i);
        case long l -> System.out.println("long: " + l);
        case float f -> System.out.println("float: " + f);
        case double d -> System.out.println("double: " + d);
        default -> System.out.println("Other number");
    }
}

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.stream.Stream;
import java.util.stream.Collectors;
// ... many more imports

import module java.base; // Imports all java.util.*, java.io.*, etc.

import module java.base;
import module java.sql;

public class DatabaseExample {
    public void process() {
        // All java.base and java.sql classes available
        List<String> names = new ArrayList<>();
        try (Connection conn = DriverManager.getConnection(url)) {
            // ...
        }
    }
}

import java.lang.classfile.*;

Path classFile = Path.of("MyClass.class");
ClassModel model = ClassFile.of().parse(classFile);

System.out.println("Class: " + model.thisClass().asInternalName());
for (MethodModel method : model.methods()) {
    System.out.println("Method: " + method.methodName());
}

ClassFile cf = ClassFile.of();
byte[] transformedBytes = cf.transform(originalBytes, (cb, ce) -> {
    if (ce instanceof MethodModel mm) {
        cb.transformMethod(mm, (mb, me) -> {
            // Add logging to each method
            mb.with(me);
        });
    } else {
        cb.with(ce);
    }
});

// distinctBy: Remove duplicates by key
List<Person> people = ...;
List<Person> uniqueByName = people.stream()
    .gather(Gatherers.distinctBy(Person::name))
    .toList();

// mapConcurrent: Parallel transformation
List<String> urls = ...;
List<Data> results = urls.stream()
    .gather(Gatherers.mapConcurrent(url -> fetchData(url)))
    .toList();

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    scope.fork(() -> fetchUserData());
    scope.fork(() -> fetchOrderData());

    scope.joinUntil(Instant.now().plusSeconds(5)); // Timeout after 5s
    scope.throwIfFailed();
}

private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

void handleRequest(User user) {
    ScopedValue.runWhere(CURRENT_USER, user, () -> {
        processRequest();
        // CURRENT_USER available in all nested calls
    });
}

class ValidatedPoint {
    final int x, y;

    public ValidatedPoint(int x, int y) {
        // Validation before field initialization
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException("Coordinates must be non-negative");
        }

        // Transform before super()
        int normalizedX = normalize(x);
        int normalizedY = normalize(y);

        this.x = normalizedX;
        this.y = normalizedY;
    }
}

// Entire program
void main() {
    String name = readLine("Enter name: ");
    println("Hello, " + name + "!");
}

// ❌ OLD: sun.misc.Unsafe
Unsafe unsafe = Unsafe.getUnsafe();
long address = unsafe.allocateMemory(1024);
unsafe.putInt(address, 42);
unsafe.freeMemory(address);

// ✅ NEW: Foreign Function & Memory API
try (Arena arena = Arena.ofConfined()) {
    MemorySegment segment = arena.allocate(1024);
    segment.set(ValueLayout.JAVA_INT, 0, 42);
} // Automatic cleanup

java --enable-preview --source 23 MyApp.java