Java 21 Features

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class VirtualThreadDemo {
    public static void main(String[] args) throws Exception {
        // Start a single virtual thread
        Thread vt = Thread.ofVirtual().name("worker-1").start(() -> {
            Thread t = Thread.currentThread();
            System.out.println("Running in " + t.getName()
                    + ", virtual = " + t.isVirtual());
        });
        vt.join();

        // One virtual thread per task: 10,000 tasks that each block 1 second
        long start = System.nanoTime();
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<Integer>> results = new ArrayList<>();
            for (int i = 0; i < 10_000; i++) {
                int id = i;
                results.add(executor.submit(() -> {
                    Thread.sleep(Duration.ofSeconds(1)); // e.g. a slow I/O call
                    return id;
                }));
            }
            long sum = 0;
            for (Future<Integer> f : results) {
                sum += f.get();
            }
            System.out.println("Tasks completed: " + results.size());
            System.out.println("Sum of task ids: " + sum);
        } // close() waits for all tasks to finish

        long seconds = Duration.ofNanos(System.nanoTime() - start).toSeconds();
        // With 10,000 platform threads this would need huge memory;
        // virtual threads finish in about one second
        System.out.println("Finished in under 5 seconds: " + (seconds < 5));
    }
}

Running in worker-1, virtual = true
Tasks completed: 10000
Sum of task ids: 49995000
Finished in under 5 seconds: true

public class SwitchPatternDemo {
    sealed interface Payment permits Card, Upi, Cash { }

    record Card(String number, double amount) implements Payment { }

    record Upi(String id, double amount) implements Payment { }

    record Cash(double amount) implements Payment { }

    // No default needed: the compiler knows every Payment type
    static String process(Payment payment) {
        return switch (payment) {
            case Card c when c.amount() > 50_000 ->
                    "Card payment needs OTP: " + c.amount();
            case Card c -> "Card ending " + c.number().substring(12);
            case Upi u -> "UPI to " + u.id();
            case Cash cash -> "Cash " + cash.amount();
        };
    }

    // Switch on any object, including a null case
    static String format(Object obj) {
        return switch (obj) {
            case null -> "null value";
            case Integer i when i < 0 -> "negative int " + i;
            case Integer i -> "int " + i;
            case String s when s.isBlank() -> "blank string";
            case String s -> "string \"" + s + "\"";
            case int[] arr -> "int array of " + arr.length;
            default -> "other: " + obj.getClass().getSimpleName();
        };
    }

    public static void main(String[] args) {
        System.out.println(process(new Card("4111222233334444", 1_200)));
        System.out.println(process(new Card("4111222233334444", 75_000)));
        System.out.println(process(new Upi("asha@bank", 499)));
        System.out.println(process(new Cash(100)));

        Object[] values = { 42, -7, "Java 21", " ", new int[3], 2.5, null };
        for (Object v : values) {
            System.out.println(format(v));
        }
    }
}

Card ending 4444
Card payment needs OTP: 75000.0
UPI to asha@bank
Cash 100.0
int 42
negative int -7
string "Java 21"
blank string
int array of 3
other: Double
null value

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class NewApiDemo {
    public static void main(String[] args) {
        // StringBuilder.repeat (Java 21)
        StringBuilder sb = new StringBuilder("ab");
        sb.repeat("-", 5).repeat('*', 3);
        System.out.println("repeat()         : " + sb);

        // String.indexOf within a range (Java 21)
        String text = "java,spring,kafka,java";
        System.out.println("indexOf(range)   : " + text.indexOf("java", 1, 22));

        // String.splitWithDelimiters keeps the separators (Java 21)
        String expr = "10+20-5";
        System.out.println("splitWithDelims  : "
                + Arrays.toString(expr.splitWithDelimiters("[+-]", 0)));

        // Math.clamp keeps a value within a range (Java 21)
        System.out.println("clamp(150,0,100) : " + Math.clamp(150, 0, 100));
        System.out.println("clamp(-8,0,100)  : " + Math.clamp(-8, 0, 100));

        // Character.isEmoji (Java 21)
        int rocket = "🚀".codePointAt(0);
        System.out.println("isEmoji(rocket)  : " + Character.isEmoji(rocket));
        System.out.println("isEmoji('A')     : " + Character.isEmoji('A'));

        // HashMap.newHashMap sizes the map for n entries (Java 19)
        Map<String, Integer> map = HashMap.newHashMap(100);
        map.put("users", 100);
        System.out.println("newHashMap(100)  : " + map);
    }
}

repeat()         : ab-----***
indexOf(range)   : 18
splitWithDelims  : [10, +, 20, -, 5]
clamp(150,0,100) : 100
clamp(-8,0,100)  : 0
isEmoji(rocket)  : true
isEmoji('A')     : false
newHashMap(100)  : {users=100}

# Generational ZGC (JEP 439): better throughput, low pauses
java -XX:+UseZGC -XX:+ZGenerational -jar app.jar

# Java 18: UTF-8 is the default charset on every OS
# (files, readers and writers no longer depend on the platform)

# Java 18: a simple web server for static files and testing
jwebserver --port 8000 --directory ./site

# Java 21: Key Encapsulation Mechanism API (javax.crypto.KEM)
# Java 21: warning when an agent is loaded into a running JVM
# Deprecated: finalization (Java 18), 32-bit Windows port (Java 21)