Java: Streams, Records, Generics and Concurrency Reference Guide

# Pick a JDK (LTS preferred)
sdk install java 21.0.4-tem     # Temurin via SDKMAN
brew install --cask temurin@21  # macOS Homebrew
java -version                   # confirm

# Build tools
brew install maven
brew install gradle

# New Maven project
mvn archetype:generate -DgroupId=com.example -DartifactId=app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false
cd app && mvn package && java -jar target/app-1.0-SNAPSHOT.jar

# New Gradle project
gradle init --type java-application --dsl kotlin
./gradlew run

# Run a single .java file (JEP 330, Java 11+)
java HelloWorld.java

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

record Order(long id, String status, int total) {}

List orders = List.of(
    new Order(1, "shipped",   120),
    new Order(2, "shipped",    80),
    new Order(3, "pending",  1500)
);

// filter -> map -> collect
List shippedIds = orders.stream()
    .filter(o -> "shipped".equals(o.status()))
    .map(Order::id)
    .toList();                                  // immutable list (Java 16+)

// group + sum
Map totalByStatus = orders.stream()
    .collect(Collectors.groupingBy(
        Order::status,
        Collectors.summingInt(Order::total)));

// Parallel — only when the work is CPU-bound + safe
long bigSum = Stream.iterate(1L, n -> n + 1)
    .limit(1_000_000)
    .parallel()
    .reduce(0L, Long::sum);

// Early exit
Optional firstBig = orders.stream()
    .filter(o -> o.total() > 1000)
    .findFirst();

// Record — immutable data carrier (Java 16+)
public record User(long id, String name, String email) {
    // Compact constructor for validation
    public User {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name");
    }
    // Static factory
    public static User of(long id, String name) {
        return new User(id, name, name.toLowerCase() + "@example.com");
    }
}

// Sealed interface — finite set of subtypes (Java 17+)
public sealed interface Shape permits Circle, Square, Triangle {}
public record Circle(double r)     implements Shape {}
public record Square(double s)     implements Shape {}
public record Triangle(double a, double b, double c) implements Shape {}

// Pattern matching for switch + records (Java 21)
public static double area(Shape s) {
    return switch (s) {
        case Circle(double r)               -> Math.PI * r * r;
        case Square(double side)            -> side * side;
        case Triangle(var a, var b, var c)  -> {
            double p = (a + b + c) / 2;
            yield Math.sqrt(p * (p - a) * (p - b) * (p - c));
        }
    };
}

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

// Virtual threads (Java 21+) — millions of cheap threads
try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000; i++) {
        int id = i;
        exec.submit(() -> handle(id));
    }
}                                            // auto-joins on close

// Structured concurrency (preview / stabilising in 25)
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var user  = scope.fork(() -> fetchUser(1));
    var perms = scope.fork(() -> fetchPermissions(1));
    scope.join().throwIfFailed();
    return new Profile(user.get(), perms.get());
}

// CompletableFuture — async composition
CompletableFuture cf = CompletableFuture
    .supplyAsync(() -> fetch(url))
    .thenApply(String::trim)
    .exceptionally(ex -> "fallback");

// Lock-free counter
AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse.BodyHandlers;
import java.time.Duration;
import java.util.List;
import java.util.concurrent.Executors;

// End-to-end: parallel GET against N URLs using virtual threads + HttpClient.
public final class FetchAll {

    record Result(String url, int status, int bytes) {}

    public static void main(String[] args) {
        var urls = List.of(
            "https://example.com",
            "https://example.org",
            "https://www.python.org"
        );

        try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
            var client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5))
                .build();

            var futures = urls.stream()
                .map(url -> exec.submit(() -> fetch(client, url)))
                .toList();

            for (var f : futures) {
                try { System.out.println(f.get()); }
                catch (Exception e) { System.err.println(e.getMessage()); }
            }
        }
    }

    static Result fetch(HttpClient c, String url) throws Exception {
        var req  = HttpRequest.newBuilder(URI.create(url))
            .timeout(Duration.ofSeconds(10)).GET().build();
        var resp = c.send(req, BodyHandlers.ofString());
        return new Result(url, resp.statusCode(), resp.body().length());
    }
}