Free sample

sealed interface Shape permits Circle, Rect, Square {}
record Circle(double r) implements Shape {}
record Rect(double w, double h) implements Shape {}
record Square(double side) implements Shape {}

static String describe(Shape s) {
    return switch (s) {
        case null -> "nothing";
…

List<String> tasks = new ArrayList<>(List.of("draft", "spam", "review", "spam"));

// Throws ConcurrentModificationException
for (String t : tasks) {
    if (t.equals("spam")) tasks.remove(t);
}

// Fine: the iterator removes and stays in sync
…

List<String> names = List.of("mira", "Zed", "ann", "mira", "Bo");

new HashSet<>(names);       // e.g. [ann, Bo, mira, Zed] (order not guaranteed)
new LinkedHashSet<>(names); // [mira, Zed, ann, Bo]
new TreeSet<>(names);       // [Bo, Zed, ann, mira] (uppercase sorts first)

// Comparator decides duplicates in a TreeSet
Set<String> tags = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
…

List<String> words = new ArrayList<>(List.of("tea", "cofee", "juice"));

// ListIterator: fix a typo in place and insert after it
ListIterator<String> li = words.listIterator();
while (li.hasNext()) {
    if (li.next().equals("cofee")) {
        li.set("coffee");
        li.add("cocoa");     // inserted after "coffee"
…

record Order(int id) {}
static final Order DONE = new Order(-1); // poison pill

public static void main(String[] args) throws Exception {
    BlockingQueue<Order> queue = new ArrayBlockingQueue<>(100);
    int consumers = 2;

    Thread producer = Thread.ofPlatform().start(() -> {
…

static boolean isPrime(int n) {
    if (n < 2) return false;
    for (int d = 2; (long) d * d <= n; d++) if (n % d == 0) return false;
    return true;
}

// Good fit: big range, CPU-only work, cheap merge
long primes = IntStream.range(0, 5_000_000).parallel().filter(Main::isPrime).count();
…

sealed interface Payment permits Card, Wallet, BankTransfer {}
record Card(String last4) implements Payment {}
record Wallet(String provider) implements Payment {}
record BankTransfer(String iban) implements Payment {}

static double feePercent(Payment p) {
    return switch (p) {           // exhaustive: no default needed
        case Card c -> 2.9;
…

// ThreadLocal: you must clean up yourself
static final ThreadLocal<String> TENANT = new ThreadLocal<>();

void handleOld(Request req) {
    TENANT.set(req.tenant());
    try {
        billing.charge(req);       // deep code calls TENANT.get()
    } finally {
…

final class Money {
    private final long cents;
    private final String currency;

    Money(long cents, String currency) { this.cents = cents; this.currency = currency; }

    @Override public boolean equals(Object o) {
        if (this == o) return true;
…

final class TenantHolder {
    private static final ThreadLocal<String> TENANT_ID = new ThreadLocal<>();
    static void bind(String tenantId) { TENANT_ID.set(tenantId); }
    static String tenant() { return TENANT_ID.get(); }
    static void unbind() { TENANT_ID.remove(); }
}

// Runs on a pooled worker thread for each incoming job
…

class SumTask extends RecursiveTask<Long> {
    private static final int CUTOFF = 10_000;
    private final long[] data;
    private final int from, to;

    SumTask(long[] data, int from, int to) { this.data = data; this.from = from; this.to = to; }

    @Override protected Long compute() {
…

// Before: escapes and concatenation
String oldJson = "{\n" +
                 "  \"sku\": \"%s\",\n" +
                 "  \"qty\": %d\n" +
                 "}\n";

// After: what you see is what you get
String json = """
…

Map<String, Integer> stock = new HashMap<>();
stock.put("apple", 10);               // null: new key
Integer before = stock.put("apple", 7); // 10: value replaced
stock.put(null, 0);                   // allowed, lives in bucket 0

String city = "lisbon";
city.toUpperCase();                 // result thrown away; city is still "lisbon"
String shout = city.toUpperCase();  // "LISBON": a new object

String x = "lisbon";
boolean shared = (city == x);       // true: both point to the pooled literal

// Many appends: one mutable buffer, one final String
…

List<Integer> linked = new LinkedList<>();
List<Integer> array = new ArrayList<>();
for (int i = 0; i < 100_000; i++) { linked.add(i); array.add(i); }

// O(n²) on LinkedList: every get(i) walks the chain
long slow = 0;
for (int i = 0; i < linked.size(); i++) slow += linked.get(i);

…

class Downloader {
    private volatile boolean cancelled;           // one writer, many readers
    private final AtomicLong bytes = new AtomicLong();
    private final List<String> failed = new ArrayList<>();
    private int failures;

    void cancel() { cancelled = true; }           // seen by worker threads promptly

…

// Checked: the caller can decide to retry or pick another file
static String loadTemplate(Path path) throws IOException {
    return Files.readString(path);
}

// Unchecked: a caller passing a negative quantity has a bug
static void reserve(String sku, int qty) {
    if (qty <= 0) throw new IllegalArgumentException("qty must be positive, got " + qty);
…

// Greeter.java
public class Greeter {
    public static void main(String[] args) {
        System.out.println("Running on " + System.getProperty("java.vm.name")
                + " " + Runtime.version());
    }
}

final class Invoice {                       // can't be subclassed
    private final List<String> lines = new ArrayList<>();
    void add(String l) { lines.add(l); }    // fine: the list is mutable, the reference isn't
}

static int attempts() {
    int n = 1;
    try {
…

// 3. Double-checked locking: volatile is required
final class RateLimiter {
    private static volatile RateLimiter instance;
    private RateLimiter() {}
    static RateLimiter get() {
        RateLimiter local = instance;          // one volatile read on the fast path
        if (local == null) {
            synchronized (RateLimiter.class) {
…