Java Conditionals — Senior Level¶

public class Main {
    // The JIT will profile this method.
    // If 99% of calls have positive values, the JIT will:
    // 1. Inline the "positive" path as the main code
    // 2. Put the "negative" path behind an uncommon trap
    static String classify(int value) {
        if (value >= 0) {
            return "positive"; // hot path — optimized
        } else {
            return "negative"; // cold path — uncommon trap
        }
    }

    public static void main(String[] args) {
        // Warm up with mostly positive values
        for (int i = 0; i < 100_000; i++) {
            classify(i);
        }
        // After JIT compilation, negative path is deoptimized
        System.out.println(classify(-1)); // triggers uncommon trap
        System.out.println("JIT recompiles if negative path becomes frequent");
    }
}

import java.util.function.Predicate;

public class Main {
    record User(String name, int age, boolean isPremium, double balance) {}

    // Specifications as composable predicates
    static Predicate<User> isAdult() { return u -> u.age() >= 18; }
    static Predicate<User> isPremium() { return User::isPremium; }
    static Predicate<User> hasMinBalance(double min) { return u -> u.balance() >= min; }

    // Compose specifications
    static Predicate<User> eligibleForLoan() {
        return isAdult()
            .and(isPremium())
            .and(hasMinBalance(1000));
    }

    public static void main(String[] args) {
        User alice = new User("Alice", 30, true, 5000);
        User bob = new User("Bob", 17, false, 200);

        Predicate<User> spec = eligibleForLoan();
        System.out.println("Alice eligible: " + spec.test(alice)); // true
        System.out.println("Bob eligible: " + spec.test(bob));     // false
    }
}

public class Main {
    // Sealed hierarchy
    sealed interface Expr permits Num, Add, Mul {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}
    record Mul(Expr left, Expr right) implements Expr {}

    // Approach 1: Pattern matching switch (Java 21+)
    static int evaluate(Expr expr) {
        return switch (expr) {
            case Num n -> n.value();
            case Add a -> evaluate(a.left()) + evaluate(a.right());
            case Mul m -> evaluate(m.left()) * evaluate(m.right());
        };
    }

    // Approach 2: Visitor pattern (classic OOP)
    // interface ExprVisitor<R> {
    //     R visitNum(Num n);
    //     R visitAdd(Add a);
    //     R visitMul(Mul m);
    // }
    // Each Expr class has: R accept(ExprVisitor<R> visitor);
    // Visitor defines operations externally

    public static void main(String[] args) {
        // (2 + 3) * 4
        Expr expr = new Mul(new Add(new Num(2), new Num(3)), new Num(4));
        System.out.println("Result: " + evaluate(expr)); // 20
    }
}

import java.util.*;
import java.util.function.Predicate;

public class Main {
    record Order(String customerId, double total, String country, boolean isFirstOrder) {}

    // Rule: encapsulates a predicate + name + action
    record Rule(String name, Predicate<Order> condition, String discount) {}

    static List<Rule> buildRules() {
        return List.of(
            new Rule("First order discount",
                Order::isFirstOrder, "10% off"),
            new Rule("High-value order",
                o -> o.total() > 500, "Free shipping"),
            new Rule("EU customer loyalty",
                o -> Set.of("DE", "FR", "NL").contains(o.country()) && o.total() > 100,
                "5% loyalty bonus"),
            new Rule("Bulk order",
                o -> o.total() > 2000, "Priority processing")
        );
    }

    public static void main(String[] args) {
        Order order = new Order("C123", 750.0, "DE", true);
        List<Rule> rules = buildRules();

        System.out.println("Order: " + order);
        System.out.println("Applied rules:");
        rules.stream()
            .filter(rule -> rule.condition().test(order))
            .forEach(rule -> System.out.println("  - " + rule.name() + ": " + rule.discount()));
    }
}

public class Main {
    enum State { IDLE, PROCESSING, COMPLETED, FAILED }
    enum Event { START, SUCCESS, ERROR, RESET }

    static State transition(State current, Event event) {
        return switch (current) {
            case IDLE -> switch (event) {
                case START -> State.PROCESSING;
                default -> current;
            };
            case PROCESSING -> switch (event) {
                case SUCCESS -> State.COMPLETED;
                case ERROR -> State.FAILED;
                default -> current;
            };
            case COMPLETED, FAILED -> switch (event) {
                case RESET -> State.IDLE;
                default -> current;
            };
        };
    }

    public static void main(String[] args) {
        State state = State.IDLE;
        Event[] events = {Event.START, Event.SUCCESS, Event.RESET, Event.START, Event.ERROR};

        for (Event e : events) {
            State next = transition(state, e);
            System.out.printf("%s + %s -> %s%n", state, e, next);
            state = next;
        }
    }
}

import java.util.*;

public class Main {
    record Request(String token, String body, String ip) {}
    record Response(int status, String message) {}

    interface Handler {
        Optional<Response> handle(Request req);
    }

    static Handler authHandler = req ->
        req.token() == null ? Optional.of(new Response(401, "Unauthorized")) : Optional.empty();

    static Handler validationHandler = req ->
        req.body() == null || req.body().isBlank()
            ? Optional.of(new Response(400, "Body required"))
            : Optional.empty();

    static Handler rateLimitHandler = req ->
        "blocked-ip".equals(req.ip())
            ? Optional.of(new Response(429, "Rate limited"))
            : Optional.empty();

    static Response processChain(Request req, List<Handler> chain) {
        for (Handler h : chain) {
            Optional<Response> result = h.handle(req);
            if (result.isPresent()) return result.get();
        }
        return new Response(200, "OK: " + req.body());
    }

    public static void main(String[] args) {
        List<Handler> chain = List.of(authHandler, validationHandler, rateLimitHandler);

        System.out.println(processChain(new Request(null, "data", "1.2.3.4"), chain));
        System.out.println(processChain(new Request("tok", "", "1.2.3.4"), chain));
        System.out.println(processChain(new Request("tok", "payload", "1.2.3.4"), chain));
    }
}

import java.util.*;
import java.util.function.*;

public class Main {
    record ValidationResult(boolean valid, String error) {
        static ValidationResult ok() { return new ValidationResult(true, null); }
        static ValidationResult fail(String error) { return new ValidationResult(false, error); }
    }

    @FunctionalInterface
    interface Validator<T> {
        ValidationResult validate(T input);

        default Validator<T> and(Validator<T> other) {
            return input -> {
                ValidationResult result = this.validate(input);
                return result.valid() ? other.validate(input) : result;
            };
        }
    }

    public static void main(String[] args) {
        Validator<String> notNull = s ->
            s != null ? ValidationResult.ok() : ValidationResult.fail("is null");
        Validator<String> notEmpty = s ->
            !s.isEmpty() ? ValidationResult.ok() : ValidationResult.fail("is empty");
        Validator<String> hasAt = s ->
            s.contains("@") ? ValidationResult.ok() : ValidationResult.fail("missing @");

        Validator<String> emailValidator = notNull.and(notEmpty).and(hasAt);

        for (String email : List.of("test@example.com", "", "invalid", null)) {
            try {
                ValidationResult r = emailValidator.validate(email);
                System.out.printf("'%s' -> %s%n", email, r.valid() ? "VALID" : "INVALID: " + r.error());
            } catch (NullPointerException e) {
                System.out.printf("'null' -> INVALID: is null%n");
            }
        }
    }
}

public class Main {
    sealed interface Result<T> permits Success, Failure {}
    record Success<T>(T value) implements Result<T> {}
    record Failure<T>(String error, Exception cause) implements Result<T> {}

    static Result<Integer> divide(int a, int b) {
        if (b == 0) return new Failure<>("Division by zero", new ArithmeticException());
        return new Success<>(a / b);
    }

    static String handleResult(Result<Integer> result) {
        return switch (result) {
            case Success<Integer> s -> "Result: " + s.value();
            case Failure<Integer> f -> "Error: " + f.error();
        };
    }

    public static void main(String[] args) {
        System.out.println(handleResult(divide(10, 3)));
        System.out.println(handleResult(divide(10, 0)));
    }
}

// Bad: conditional dispatch based on deserialized class type
Object obj = objectInputStream.readObject(); // attacker controls the type
if (obj instanceof AdminCommand cmd) {
    cmd.execute(); // arbitrary code execution!
}

// Better: whitelist allowed types before dispatch
private static final Set<Class<?>> ALLOWED_TYPES = Set.of(UserCommand.class, QueryCommand.class);

Object obj = objectInputStream.readObject();
if (!ALLOWED_TYPES.contains(obj.getClass())) {
    throw new SecurityException("Unauthorized command type: " + obj.getClass());
}

public class Main {
    // Branch: JIT must predict the outcome
    static int maxBranch(int a, int b) {
        return a > b ? a : b;
    }

    // Branch-free: no prediction needed
    static int maxBranchFree(int a, int b) {
        int diff = a - b;
        int mask = diff >> 31; // 0 if a >= b, -1 if a < b
        return a - (diff & mask);
    }

    public static void main(String[] args) {
        System.out.println(maxBranch(5, 3));       // 5
        System.out.println(maxBranchFree(5, 3));   // 5
        System.out.println(maxBranchFree(3, 5));   // 5

        // In practice, Math.max() is intrinsified by the JIT
        // and is the fastest option. The JIT converts it to
        // a single CMOV instruction on x86.
        System.out.println(Math.max(5, 3));        // 5
    }
}

public class Main {
    // The compiler converts String switch to:
    // 1. hashCode() computation
    // 2. lookupswitch on hash
    // 3. equals() verification (for hash collisions)
    static String optimizedStringSwitch(String command) {
        return switch (command) {
            case "GET"    -> "read";
            case "POST"   -> "create";
            case "PUT"    -> "update";
            case "DELETE" -> "delete";
            default       -> "unknown";
        };
    }

    // For hot paths, enum dispatch is faster (no hash computation)
    enum HttpMethod { GET, POST, PUT, DELETE }

    static String enumDispatch(HttpMethod method) {
        return switch (method) {
            case GET    -> "read";
            case POST   -> "create";
            case PUT    -> "update";
            case DELETE -> "delete";
        };
    }

    public static void main(String[] args) {
        System.out.println(optimizedStringSwitch("POST"));
        System.out.println(enumDispatch(HttpMethod.POST));
    }
}

// External library defines:
// enum ThirdPartyStatus { ACTIVE, INACTIVE }

// Your code:
String msg = switch (status) {
    case ACTIVE -> "ok";
    case INACTIVE -> "disabled";
};
// Compiles fine. BUT if the library adds a new constant (e.g., PENDING)
// in a newer version, your code throws MatchException at RUNTIME
// (not compile time — because the enum class file changed after your compilation)

// Compile error: "this pattern is dominated by..."
return switch (obj) {
    case Number n -> "number";          // catches Integer too!
    case Integer i -> "integer";        // unreachable!
    default -> "other";
};

// Fix: specific patterns must come before general patterns
return switch (obj) {
    case Integer i -> "integer";        // specific first
    case Number n -> "number";          // general second
    default -> "other";
};

// Over-engineered: Strategy pattern for 2 conditions
interface GreetingStrategy { String greet(String name); }
class FormalGreeting implements GreetingStrategy { ... }
class CasualGreeting implements GreetingStrategy { ... }

// Simple and perfectly fine:
String greet(String name, boolean formal) {
    return formal ? "Good day, " + name : "Hey " + name + "!";
}

// Production code relies on short-circuit
if (cache.contains(key) && !isExpired(cache.get(key))) {
    return cache.get(key); // assumes cache.contains was true
}

// Bug: if another thread removes the key between contains() and get(),
// get() returns null and isExpired throws NPE

byte b = 2;
switch (b) {
    case 1: // This is an int literal, but Java narrows it to byte automatically
        break;
    case 128: // COMPILE ERROR: 128 doesn't fit in byte (-128 to 127)
        break;
}

Object obj = null;
String result = switch (obj) {
    case String s -> "string";
    case null -> "null";        // must handle null explicitly
    default -> "other";
};
// Works: "null"

// But if you write: case null, default -> "null or other"
// This is also valid — null and default can share a case arm

String classify(String input) {
    if (input.startsWith("ERROR")) return "error";
    if (input.startsWith("WARN")) return "warning";
    if (input.startsWith("INFO")) return "info";
    if (input.startsWith("DEBUG")) return "debug";
    if (input.startsWith("TRACE")) return "trace";
    return "unknown";
}

Integer a = 1;
Integer b = 1;
boolean result = (a == b) ? Boolean.TRUE : Boolean.FALSE;