Most Java runtime failures cluster around a handful of exceptions. NullPointerException, ClassCastException, ArrayIndexOutOfBoundsException, ConcurrentModificationException — these appear in stack traces so frequently that recognising them on sight, knowing exactly what triggers each one, and knowing how to prevent them is a core production skill. This article covers every exception you are likely to encounter in a Java codebase and the pattern that fixes each one.

Overview of Common Exceptions

QUICK REFERENCE — MOST COMMON JAVA EXCEPTIONS:

  UNCHECKED (RuntimeException subclasses):
    NullPointerException           — method called on null reference
    ArrayIndexOutOfBoundsException — array access beyond valid index range
    StringIndexOutOfBoundsException — String.charAt() beyond string length
    ClassCastException             — invalid cast between incompatible types
    NumberFormatException          — non-numeric string parsed as number
    IllegalArgumentException       — method called with invalid argument
    IllegalStateException          — object used in wrong lifecycle state
    ArithmeticException            — division by zero (integer arithmetic)
    UnsupportedOperationException  — mutation on read-only / fixed-size view
    ConcurrentModificationException — collection structurally modified during iteration
    StackOverflowError             — infinite recursion exhausts call stack
                                    (Error, not RuntimeException — different root)

  CHECKED (Exception subclasses — must catch or declare):
    IOException / FileNotFoundException — file or I/O operation fails
    SQLException                       — database operation fails
    ClassNotFoundException             — Class.forName() cannot find class
    InterruptedException               — thread interrupted during wait/sleep

  MODERN ADDITIONS:
    NullPointerException (Java 14+) — helpful NPE messages naming the null field

When Each Exception Occurs

CAUSE SUMMARY:
  NullPointerException       → dereference a null reference
  ArrayIndexOutOfBounds      → index < 0 or index >= array.length
  ClassCastException         → cast to incompatible type (fails instanceof)
  NumberFormatException      → Integer.parseInt("abc") or similar
  IllegalArgumentException   → argument violates method's documented contract
  IllegalStateException      → call sequence out of order (not initialized yet)
  ArithmeticException        → integer division by 0 (not double — double returns Infinity)
  UnsupportedOperationException → add/remove on List.of(), Arrays.asList(),
                                  Collections.unmodifiableList() view
  ConcurrentModificationException → for-each loop with list.remove() inside
  StackOverflowError         → recursive method with no reachable base case
  IOException                → file missing, stream closed, network down
  ClassNotFoundException     → Class.forName("com.example.Missing")

NullPointerException

NullPointerException (NPE) is the most common exception in Java codebases. It is thrown when code attempts to use a reference that holds null as if it pointed to an object — calling a method on it, accessing a field through it, or using it where a value is expected in autoboxing.

Java 14 introduced helpful NPE messages that name exactly which variable or expression was null, eliminating much of the guesswork in debugging.

Java

// File: NullPointerExceptionDemo.java

import java.util.Map;
import java.util.Optional;

public class NullPointerExceptionDemo {

    record UserProfile(String name, String email, Address address) {}
    record Address(String city, String pinCode) {}

    // WRONG — NPE if user is null, or user.address() is null, or user.address().city() is null
    static String getCityUnsafe(UserProfile user) {
        return user.address().city().toUpperCase(); // multiple NPE points
    }

    // CORRECT — null-check each level before dereferencing
    static String getCitySafe(UserProfile user) {
        if (user == null) return "unknown";
        if (user.address() == null) return "no address";
        if (user.address().city() == null) return "no city";
        return user.address().city().toUpperCase();
    }

    // MODERN — Optional eliminates null checks for optional values
    static Optional<String> getCityOptional(UserProfile user) {
        return Optional.ofNullable(user)
            .map(UserProfile::address)
            .map(Address::city)
            .map(String::toUpperCase);
    }

    // Autoboxing NPE — often missed by beginners
    static int getScoreUnsafe(Map<String, Integer> scores, String userId) {
        return scores.get(userId); // NPE if key is absent: unboxing null Integer to int
    }

    static int getScoreSafe(Map<String, Integer> scores, String userId) {
        return scores.getOrDefault(userId, 0); // safe: returns 0 if absent
    }

    public static void main(String[] args) {

        System.out.println("=== Null chain navigation ===");
        UserProfile complete = new UserProfile("Priya", "priya@example.com",
            new Address("Bengaluru", "560001"));
        UserProfile noAddress = new UserProfile("Rohan", "rohan@example.com", null);

        System.out.println(getCitySafe(complete));
        System.out.println(getCitySafe(noAddress));
        System.out.println(getCitySafe(null));

        System.out.println();

        System.out.println("=== Optional chaining ===");
        System.out.println(getCityOptional(complete).orElse("unknown"));
        System.out.println(getCityOptional(noAddress).orElse("unknown"));
        System.out.println(getCityOptional(null).orElse("unknown"));

        System.out.println();

        System.out.println("=== Autoboxing NPE ===");
        Map<String, Integer> scores = Map.of("user-001", 95, "user-002", 88);
        System.out.println("user-001 score: " + getScoreSafe(scores, "user-001"));
        System.out.println("user-003 score: " + getScoreSafe(scores, "user-003")); // absent key

        try {
            getScoreUnsafe(scores, "user-003"); // absent key → null → unboxing NPE
        } catch (NullPointerException npe) {
            System.out.println("NPE on unboxing absent map value: " + npe.getMessage());
        }
    }
}

Output:
=== Null chain navigation ===
BENGALURU
no address
unknown

=== Optional chaining ===
BENGALURU
unknown
unknown

=== Autoboxing NPE ===
user-001 score: 95
user-003 score: 0
NPE on unboxing absent map value: Cannot unbox null value

ArrayIndexOutOfBoundsException

Thrown when accessing an array using an index that is negative or greater than or equal to the array's length. The valid index range for an array of length n is always [0, n-1].

Java

// File: ArrayIndexDemo.java

import java.util.Arrays;
import java.util.List;

public class ArrayIndexDemo {

    // Most common cause: off-by-one in loops
    static int sumUnsafe(int[] numbers) {
        int total = 0;
        for (int i = 0; i <= numbers.length; i++) { // WRONG: should be i < numbers.length
            total += numbers[i]; // ArrayIndexOutOfBoundsException at i == numbers.length
        }
        return total;
    }

    static int sumSafe(int[] numbers) {
        int total = 0;
        for (int num : numbers) { // for-each eliminates index arithmetic entirely
            total += num;
        }
        return total;
    }

    // Getting the last element — common off-by-one
    static int lastElement(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            throw new IllegalArgumentException("Array must not be null or empty");
        }
        return numbers[numbers.length - 1]; // CORRECT: length-1, not length
    }

    public static void main(String[] args) {

        int[] scores = {85, 92, 78, 95, 88};

        System.out.println("=== Safe array operations ===");
        System.out.println("Sum     : " + sumSafe(scores));
        System.out.println("Last    : " + lastElement(scores));
        System.out.println("Length  : " + scores.length);
        System.out.println("Index 0 : " + scores[0]);
        System.out.println("Index 4 : " + scores[4]); // valid: length-1

        System.out.println();

        System.out.println("=== Boundary violation ===");
        try {
            int bad = scores[5]; // index 5, length is 5 — invalid
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught: " + e.getMessage());
        }
        try {
            int neg = scores[-1]; // negative index
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        System.out.println();

        // List is safer — get(index) throws IndexOutOfBoundsException with better message
        System.out.println("=== List vs array bounds check ===");
        List<Integer> list = List.of(85, 92, 78, 95, 88);
        try {
            list.get(10);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("List bounds: " + e.getMessage());
        }
    }
}

Output:
=== Safe array operations ===
Sum     : 438
Last    : 88
Length  : 5
Index 0 : 85
Index 4 : 88

=== Boundary violation ===
Caught: Index 5 out of bounds for length 5
Caught: Index -1 out of bounds for length 5

=== List vs array bounds check ===
List bounds: Index: 10, Size: 5

ClassCastException

Thrown when an object is cast to a type it is not an instance of. The instanceof operator checks this at runtime and returns false before a cast that would fail.

Java

// File: ClassCastDemo.java

import java.util.ArrayList;
import java.util.List;

public class ClassCastDemo {

    sealed interface Shape permits Circle, Rectangle {}
    record Circle(double radius) implements Shape {}
    record Rectangle(double width, double height) implements Shape {}

    // WRONG — assumes all shapes are Circles
    static double getRadiusUnsafe(Shape shape) {
        return ((Circle) shape).radius(); // ClassCastException if shape is Rectangle
    }

    // CORRECT — instanceof check before cast
    static double getRadiusSafe(Shape shape) {
        if (shape instanceof Circle circle) {
            return circle.radius(); // Java 16+ pattern matching — no explicit cast
        }
        return 0.0; // or throw a domain exception
    }

    // The raw type trap — pre-generics code or suppressed warnings
    static void demonstrateRawTypeCCE() {
        List rawList = new ArrayList(); // raw type — no generic type safety
        rawList.add("hello");
        rawList.add(42); // different types allowed in raw list

        try {
            for (Object obj : rawList) {
                String s = (String) obj; // ClassCastException when Integer is cast to String
                System.out.println("Value: " + s);
            }
        } catch (ClassCastException cce) {
            System.out.println("ClassCastException from raw list: " +
                cce.getMessage());
        }
    }

    public static void main(String[] args) {

        Shape circle    = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);

        System.out.println("=== instanceof before cast ===");
        System.out.printf("Circle radius    : %.1f%n", getRadiusSafe(circle));
        System.out.printf("Rectangle radius : %.1f (not a circle)%n", getRadiusSafe(rectangle));

        System.out.println();

        System.out.println("=== Unsafe cast caught ===");
        try {
            double radius = getRadiusUnsafe(rectangle);
        } catch (ClassCastException cce) {
            System.out.println("ClassCastException: " + cce.getMessage());
        }

        System.out.println();

        System.out.println("=== Raw type CCE ===");
        demonstrateRawTypeCCE();
    }
}

Output:
=== instanceof before cast ===
Circle radius    : 5.0
Rectangle radius : 0.0 (not a circle)

=== Unsafe cast caught ===
ClassCastException: class ClassCastDemo$Rectangle cannot be cast to class ClassCastDemo$Circle

=== Raw type CCE ===
Value: hello
ClassCastException from raw list: class java.lang.Integer cannot be cast to class java.lang.String

NumberFormatException

Thrown when a string cannot be parsed into a numeric type because it contains characters that are not valid for the target format.

Java

// File: NumberFormatDemo.java

import java.util.Optional;
import java.util.OptionalInt;

public class NumberFormatDemo {

    // WRONG — throws if input is not a valid integer
    static int parseUnsafe(String input) {
        return Integer.parseInt(input); // NumberFormatException for non-numeric strings
    }

    // CORRECT — validate before parse or wrap with try-catch
    static OptionalInt parseSafe(String input) {
        if (input == null || input.isBlank()) return OptionalInt.empty();
        try {
            return OptionalInt.of(Integer.parseInt(input.trim()));
        } catch (NumberFormatException nfe) {
            return OptionalInt.empty();
        }
    }

    // Common sources of NumberFormatException
    static void demonstrateVariants() {
        String[] inputs = {"42", "3.14", "  100  ", "1,000", "0xFF", "-99", ""};

        for (String input : inputs) {
            try {
                int value = Integer.parseInt(input.trim());
                System.out.printf("  %-10s → %d (OK)%n", "\"" + input + "\"", value);
            } catch (NumberFormatException nfe) {
                System.out.printf("  %-10s → NFE: %s%n",
                    "\"" + input + "\"", nfe.getMessage());
            }
        }

        System.out.println();
        // Double.parseDouble handles decimals — use the right parser for the type
        System.out.println("Double.parseDouble(\"3.14\") = " +
            Double.parseDouble("3.14"));
        System.out.println("Integer.decode(\"0xFF\") = " +
            Integer.decode("0xFF")); // hex — use decode(), not parseInt()
    }

    public static void main(String[] args) {
        System.out.println("=== Parse variants ===");
        demonstrateVariants();

        System.out.println("=== Safe parsing with OptionalInt ===");
        String[] userInputs = {"150", "abc", null, "  75  ", "9.9"};
        for (String input : userInputs) {
            OptionalInt result = parseSafe(input);
            System.out.printf("  %-8s → %s%n",
                input,
                result.isPresent() ? result.getAsInt() : "invalid");
        }
    }
}

Output:
=== Parse variants ===
  "42"       → 42 (OK)
  "3.14"     → NFE: For input string: "3.14"
  "  100  "  → 100 (OK)
  "1,000"    → NFE: For input string: "1,000"
  "0xFF"     → NFE: For input string: "0xFF"
  "-99"      → -99 (OK)
  ""         → NFE: For input string: ""

Double.parseDouble("3.14") = 3.14
Integer.decode("0xFF") = 255

=== Safe parsing with OptionalInt ===
  150      → 150
  abc      → invalid
  null     → invalid
     75   → 75
  9.9      → invalid

UnsupportedOperationException and ConcurrentModificationException

These two exceptions share a theme: they both occur when code tries to modify a collection in a way that is not allowed. UnsupportedOperationException fires when mutation is attempted on an immutable or fixed-size view. ConcurrentModificationException fires when a collection is structurally modified during a for-each iteration.

Java

// File: CollectionExceptionsDemo.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;

public class CollectionExceptionsDemo {

    public static void main(String[] args) {

        // ---- UnsupportedOperationException ----
        System.out.println("=== UnsupportedOperationException sources ===");

        // Source 1: List.of() is fully immutable
        List<String> immutable = List.of("java", "spring", "kafka");
        try {
            immutable.add("redis");
        } catch (UnsupportedOperationException uoe) {
            System.out.println("List.of().add() → UnsupportedOperationException");
        }

        // Source 2: Arrays.asList() is fixed-size — set() works, add/remove do not
        List<String> fixedSize = Arrays.asList("a", "b", "c");
        fixedSize.set(0, "x"); // set() allowed — no structural change
        try {
            fixedSize.add("d");
        } catch (UnsupportedOperationException uoe) {
            System.out.println("Arrays.asList().add() → UnsupportedOperationException");
        }
        System.out.println("Arrays.asList after set: " + fixedSize);

        // Source 3: Collections.unmodifiableList() — read-only view
        List<String> mutable = new ArrayList<>(List.of("one", "two", "three"));
        List<String> readOnly = java.util.Collections.unmodifiableList(mutable);
        try {
            readOnly.add("four");
        } catch (UnsupportedOperationException uoe) {
            System.out.println("unmodifiableList.add() → UnsupportedOperationException");
        }

        System.out.println();

        // ---- ConcurrentModificationException ----
        System.out.println("=== ConcurrentModificationException sources ===");
        List<String> services = new ArrayList<>(
            List.of("auth", "payment", "cart", "notification"));

        // WRONG — list.remove() inside for-each
        try {
            for (String service : services) {
                if ("cart".equals(service)) {
                    services.remove(service); // structural change during iteration → CME
                }
            }
        } catch (ConcurrentModificationException cme) {
            System.out.println("list.remove() in for-each → ConcurrentModificationException");
        }
        System.out.println("List after failed removal attempt: " + services);

        System.out.println();

        System.out.println("=== Safe removal patterns ===");
        List<String> services2 = new ArrayList<>(
            List.of("auth", "payment", "cart", "notification"));

        // Pattern 1: removeIf — cleanest single-pass removal
        services2.removeIf(s -> "cart".equals(s) || "notification".equals(s));
        System.out.println("After removeIf: " + services2);

        // Pattern 2: Iterator.remove() — safe when conditional removal during iteration
        List<String> services3 = new ArrayList<>(
            List.of("auth", "payment", "cart", "notification"));
        Iterator<String> it = services3.iterator();
        while (it.hasNext()) {
            if (it.next().startsWith("c")) {
                it.remove(); // iterator.remove() — safe
            }
        }
        System.out.println("After iterator.remove(): " + services3);
    }
}

Output:
=== UnsupportedOperationException sources ===
List.of().add() → UnsupportedOperationException
Arrays.asList().add() → UnsupportedOperationException
Arrays.asList after set: [x, b, c]
unmodifiableList.add() → UnsupportedOperationException

=== ConcurrentModificationException sources ===
list.remove() in for-each → ConcurrentModificationException
List after failed removal attempt: [auth, payment, notification]

=== Safe removal patterns ===
After removeIf: [auth, payment]
After iterator.remove(): [auth, payment, notification]

IllegalArgumentException and IllegalStateException

These two often get confused. IllegalArgumentException is about the arguments passed in — the caller supplied something invalid. IllegalStateException is about the object's state — the caller invoked a method at the wrong time in the object's lifecycle.

Java

// File: IllegalExceptionsDemo.java

public class IllegalExceptionsDemo {

    // IllegalArgumentException: the argument violates the method's contract
    static double divide(double numerator, double denominator) {
        if (denominator == 0.0) {
            throw new IllegalArgumentException(
                "Denominator cannot be zero");
        }
        return numerator / denominator;
    }

    // IllegalStateException: the object is not ready for this operation
    static class DatabaseConnection {
        private boolean open = false;
        private String  url;

        void connect(String url) {
            if (open) throw new IllegalStateException(
                "Already connected — call disconnect() first");
            this.url  = url;
            this.open = true;
            System.out.println("Connected to: " + url);
        }

        String query(String sql) {
            if (!open) throw new IllegalStateException(
                "Not connected — call connect() first");
            return "result-of[" + sql + "]-from-" + url;
        }

        void disconnect() {
            if (!open) throw new IllegalStateException("Not connected");
            this.open = false;
            System.out.println("Disconnected from: " + url);
        }
    }

    public static void main(String[] args) {

        System.out.println("=== IllegalArgumentException ===");
        System.out.printf("10 / 4 = %.2f%n", divide(10, 4));
        try {
            divide(10, 0);
        } catch (IllegalArgumentException iae) {
            System.out.println("IllegalArgumentException: " + iae.getMessage());
        }

        System.out.println();

        System.out.println("=== IllegalStateException ===");
        DatabaseConnection conn = new DatabaseConnection();
        try {
            conn.query("SELECT 1"); // not connected yet
        } catch (IllegalStateException ise) {
            System.out.println("IllegalStateException: " + ise.getMessage());
        }

        conn.connect("jdbc:postgresql://localhost/orders");
        System.out.println(conn.query("SELECT COUNT(*) FROM orders"));

        try {
            conn.connect("jdbc:mysql://localhost/backup"); // already connected
        } catch (IllegalStateException ise) {
            System.out.println("IllegalStateException: " + ise.getMessage());
        }

        conn.disconnect();
    }
}

Output:
=== IllegalArgumentException ===
10 / 4 = 2.50
IllegalArgumentException: Denominator cannot be zero

=== IllegalStateException ===
IllegalStateException: Not connected — call connect() first
Connected to: jdbc:postgresql://localhost/orders
result-of[SELECT COUNT(*) FROM orders]-from-jdbc:postgresql://localhost/orders
IllegalStateException: Already connected — call disconnect() first
Disconnected from: jdbc:postgresql://localhost/orders

ArithmeticException and StackOverflowError

ArithmeticException is thrown specifically by integer division and modulo by zero — int result = 10 / 0. Note that floating-point division by zero does not throw; it returns Infinity or NaN. StackOverflowError is thrown when recursive calls exceed the JVM stack depth limit.

Java

// File: ArithmeticStackDemo.java

public class ArithmeticStackDemo {

    public static void main(String[] args) {

        // ArithmeticException — only for INTEGER division by zero
        System.out.println("=== ArithmeticException ===");
        try {
            int result = 100 / 0; // integer division by zero → ArithmeticException
        } catch (ArithmeticException ae) {
            System.out.println("int 100/0 → ArithmeticException: " + ae.getMessage());
        }

        // Double division by zero does NOT throw — returns Infinity
        double infiniteResult = 100.0 / 0.0;
        System.out.println("double 100.0/0.0 → " + infiniteResult);
        System.out.println("double 0.0/0.0   → " + (0.0 / 0.0)); // NaN

        System.out.println();

        // StackOverflowError — infinite recursion
        System.out.println("=== StackOverflowError ===");

        // WRONG: no base case
        // static int badCount(int n) { return badCount(n + 1); } → SOE

        // CORRECT: base case terminates recursion
        System.out.println("countdown(5): " + countdown(5));

        try {
            endlessRecursion(0); // no base case — SOE
        } catch (StackOverflowError soe) {
            System.out.println("StackOverflowError caught — infinite recursion detected");
        }
    }

    static String countdown(int n) {
        if (n <= 0) return "launch!"; // base case — recursion terminates
        return n + "... " + countdown(n - 1);
    }

    static void endlessRecursion(int depth) {
        endlessRecursion(depth + 1); // never reaches base case
    }
}

Output:
=== ArithmeticException ===
int 100/0 → ArithmeticException: / by zero
double 100.0/0.0 → Infinity
double 0.0/0.0   → NaN

=== StackOverflowError ===
countdown(5): 5... 4... 3... 2... 1... launch!
StackOverflowError caught — infinite recursion detected

Real-World Example — Swiggy Order Validation Service

A Swiggy order validation service handles multiple failure scenarios as orders arrive. Each exception type signals a different problem and is handled differently. The service demonstrates production-pattern exception handling: specific catches for each failure mode, IllegalArgumentException for bad input, UnsupportedOperationException awareness for collection views, and controlled exception surfacing to the API layer.

Java

// File: OrderRequest.java

import java.util.List;

public record OrderRequest(
        String          orderId,
        String          customerId,
        String          restaurantId,
        List<String>    itemIds,
        double          totalAmount,
        String          deliveryAddress) {}

Java

// File: OrderValidationException.java

public class OrderValidationException extends RuntimeException {

    private final String field;
    private final String code;

    public OrderValidationException(String field, String code, String message) {
        super(message);
        this.field = field;
        this.code  = code;
    }

    public String getField() { return field; }
    public String getCode()  { return code;  }
}

Java

// File: OrderValidationService.java

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class OrderValidationService {

    private static final Map<String, Double> MENU_PRICES = Map.of(
        "ITEM-001", 149.0,
        "ITEM-002", 249.0,
        "ITEM-003", 89.0
    );

    // Returns a validated, enriched list — throws specific exceptions per failure
    public List<String> validateAndEnrich(OrderRequest request) {

        // NullPointerException prevention — validate required fields explicitly
        if (request == null) {
            throw new IllegalArgumentException("OrderRequest must not be null");
        }
        if (request.customerId() == null || request.customerId().isBlank()) {
            throw new OrderValidationException("customerId", "MISSING_FIELD",
                "Customer ID is required");
        }
        if (request.itemIds() == null || request.itemIds().isEmpty()) {
            throw new OrderValidationException("itemIds", "EMPTY_ITEMS",
                "Order must contain at least one item");
        }

        // NumberFormatException prevention — parse amounts safely
        double declaredAmount = request.totalAmount();
        if (declaredAmount <= 0) {
            throw new OrderValidationException("totalAmount", "INVALID_AMOUNT",
                "Total amount must be positive: " + declaredAmount);
        }

        // UnsupportedOperationException prevention — never mutate a view list
        // request.itemIds() might be an unmodifiable list — copy before modifying
        List<String> enrichedItems = new ArrayList<>(request.itemIds());

        // Validate each item exists in the menu (ClassCastException safe via generics)
        double calculatedTotal = 0.0;
        for (String itemId : enrichedItems) {
            if (!MENU_PRICES.containsKey(itemId)) {
                throw new OrderValidationException("itemIds", "ITEM_NOT_FOUND",
                    "Item not found in restaurant menu: " + itemId);
            }
            calculatedTotal += MENU_PRICES.get(itemId);
        }

        // Business validation — declared total must match calculated total
        double tolerance = 0.01;
        if (Math.abs(calculatedTotal - declaredAmount) > tolerance) {
            throw new OrderValidationException("totalAmount", "AMOUNT_MISMATCH",
                String.format("Declared Rs.%.2f does not match calculated Rs.%.2f",
                    declaredAmount, calculatedTotal));
        }

        enrichedItems.add("DELIVERY_FEE"); // safe — working on our own ArrayList copy
        return enrichedItems;
    }

    public void processOrder(OrderRequest request) {
        System.out.printf("Validating order %s from customer %s...%n",
            request != null ? request.orderId() : "null",
            request != null ? request.customerId() : "null");
        try {
            List<String> enriched = validateAndEnrich(request);
            System.out.println("  Validation passed. Items: " + enriched);

        } catch (OrderValidationException ove) {
            System.out.printf("  Validation failed [%s.%s]: %s%n",
                ove.getField(), ove.getCode(), ove.getMessage());

        } catch (IllegalArgumentException iae) {
            System.out.println("  Bad request: " + iae.getMessage());

        } catch (Exception unexpected) {
            System.out.println("  Unexpected error — logged: " +
                unexpected.getClass().getSimpleName() + ": " + unexpected.getMessage());
        }
    }

    public static void main(String[] args) {
        OrderValidationService service = new OrderValidationService();

        service.processOrder(new OrderRequest(
            "ORD-001", "C-priya", "REST-101",
            List.of("ITEM-001","ITEM-002"), 398.0, "HSR Layout, Bengaluru"));

        System.out.println();

        service.processOrder(new OrderRequest(
            "ORD-002", null, "REST-101",
            List.of("ITEM-001"), 149.0, "Koramangala"));

        System.out.println();

        service.processOrder(new OrderRequest(
            "ORD-003", "C-rohan", "REST-101",
            List.of("ITEM-001","ITEM-999"), 239.0, "Indiranagar"));

        System.out.println();

        service.processOrder(new OrderRequest(
            "ORD-004", "C-ananya", "REST-101",
            List.of("ITEM-002","ITEM-003"), 500.0, "Whitefield"));
    }
}

Output:
Validating order ORD-001 from customer C-priya...
  Validation passed. Items: [ITEM-001, ITEM-002, DELIVERY_FEE]

Validating order ORD-002 from customer null...
  Validation failed [customerId.MISSING_FIELD]: Customer ID is required

Validating order ORD-003 from customer C-rohan...
  Validation failed [itemIds.ITEM_NOT_FOUND]: Item not found in restaurant menu: ITEM-999

Validating order ORD-004 from customer C-ananya...
  Validation failed [totalAmount.AMOUNT_MISMATCH]: Declared Rs.500.00 does not match calculated Rs.338.00

Performance Considerations

All exception objects carry the same construction cost: the JVM captures the full stack trace at the moment new SomeException(...) executes. This cost is the same regardless of exception type — NullPointerException and IOException pay the same price. Three practical implications:

1. Do not use exceptions for control flow in loops.
   Each thrown exception allocates a stack trace object.
   Testing "is this value in the map?" with containsKey() costs O(1).
   Catching a hypothetical exception costs microseconds per call.

2. NumberFormatException in a parsing loop is a red flag.
   If user input is expected to be sometimes invalid, validate first.
   Integer.parseInt on untrusted input inside a hot path is slow.
   Use a regex or character-level check before calling parseInt.

3. NullPointerException with helpful messages (Java 14+) has no extra cost.
   The detailed message is lazily computed — only when getMessage() is called.
   There is no performance penalty for the improved diagnostics.

Best Practices

Always validate method inputs at the entry point and throw IllegalArgumentException with a clear message. if (userId == null || userId.isBlank()) throw new IllegalArgumentException("userId must not be blank") is the right pattern. This surfaces the error at the point of the call rather than as a cryptic NPE somewhere deep inside the method body. IDEs and static analysis tools like SonarQube flag missing null checks — treat those warnings as real issues.

Use Optional for values that may legitimately be absent rather than returning null. Optional.ofNullable(map.get(key)) makes the absent case explicit in the return type. Callers must use orElse(), orElseGet(), or orElseThrow(), which prevents NPEs by construction. This is appropriate for return types — do not use Optional as a method parameter type.

Use removeIf() instead of removing elements during a for-each loop. list.removeIf(predicate) is the Java 8+ solution to ConcurrentModificationException from structural modification during iteration. It performs a single O(n) pass internally. For cases where Iterator.remove() is needed (more complex removal logic), use an explicit iterator.

Know the three sources of UnsupportedOperationException on lists. List.of() is fully immutable, Arrays.asList() is fixed-size (set() works, add/remove do not), and Collections.unmodifiableList() is a read-only view. Always copy before mutating: new ArrayList<>(existingList). During code reviews, checking that code does not mutate lists coming from API responses or record fields is a common senior developer habit.

Common Mistakes

Mistake 1 — Catching Broad Exception to Hide Specific Failures

Java

// WRONG — catches everything including NPE, CCE, and more serious failures
public String getProductName(String id) {
    try {
        return catalog.findById(id).getName();
    } catch (Exception e) {
        return "Unknown"; // hides NPE if catalog is null, CCE if cast is wrong
    }
}

// CORRECT — handle specific exceptions, let others propagate
public String getProductName(String id) {
    if (id == null || id.isBlank()) {
        throw new IllegalArgumentException("Product ID required");
    }
    Product product = catalog.findById(id); // propagate NPE if catalog is misconfigured
    return product != null ? product.getName() : "Unavailable";
}

Mistake 2 — Using Arrays.asList() and Then Calling add()

Java

// WRONG — Arrays.asList() returns a fixed-size list
// add() throws UnsupportedOperationException — this is a common beginner mistake
List<String> tags = Arrays.asList("java", "spring", "kafka");
tags.add("docker"); // UnsupportedOperationException at runtime

// CORRECT — wrap in ArrayList for a resizable copy
List<String> tags = new ArrayList<>(Arrays.asList("java", "spring", "kafka"));
tags.add("docker"); // works fine
System.out.println(tags); // [java, spring, kafka, docker]

Mistake 3 — Trusting Map.get() Without Null Check Before Unboxing

Java

Map<String, Integer> retryCount = new HashMap<>();
retryCount.put("ORD-001", 3);

// WRONG — Map.get() returns null for absent keys; unboxing null throws NPE
int count = retryCount.get("ORD-002"); // NullPointerException

// CORRECT — use getOrDefault() for primitive values
int count = retryCount.getOrDefault("ORD-002", 0); // returns 0 if absent

Mistake 4 — Misidentifying the Root Cause When CCE Occurs Mid-Collection

Java

// WRONG — modifying a shared map while iterating its values
Map<String, Integer> scores = new HashMap<>(Map.of("A",1,"B",2,"C",3));
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    if (entry.getValue() < 2) {
        scores.remove(entry.getKey()); // ConcurrentModificationException
    }
}

// CORRECT — use removeIf on entrySet
scores.entrySet().removeIf(entry -> entry.getValue() < 2);
System.out.println(scores); // {B=2, C=3}

Output:
{B=2, C=3}

Interview Questions

Q1. What is NullPointerException and what are the common ways to prevent it?

NullPointerException is thrown when code dereferences a null reference — calling a method, accessing a field, or unboxing a null Integer to int. Prevention strategies: validate method arguments at entry points with explicit null checks and throw IllegalArgumentException; use Optional<T> for return types that may legitimately be absent; use getOrDefault() instead of get() on maps when unboxing; and in Java 14+, NPE messages include the exact variable name that was null, making debugging much faster.

Q2. What causes ConcurrentModificationException and how do you fix it?

ConcurrentModificationException is thrown when a collection's structural modification count (modCount) changes between an iterator's creation and its next hasNext() or next() call. The most common trigger: calling list.remove() or list.add() inside a for-each loop. The for-each loop creates an iterator at the start; list.remove() increments modCount; the iterator detects the mismatch on the next call. Fix: use list.removeIf(predicate) for conditional removal (cleanest), iterator.remove() inside an explicit iterator loop, or collect the items to remove first and then call removeAll.

Q3. What is the difference between IllegalArgumentException and IllegalStateException?

IllegalArgumentException is about the arguments a caller passed — the caller provided a value that violates the method's documented contract: null where non-null is required, a negative number where a positive was expected. The caller needs to fix the argument. IllegalStateException is about the state of the object at the time of the call — the method was invoked in the wrong order or on an object not yet ready: calling query() before connect(), accessing a closed stream, using an iterator that has been exhausted. The caller needs to fix the call sequence.

Q4. Why does double division by zero not throw ArithmeticException in Java?

Java follows IEEE 754 floating-point arithmetic for double and float. Division by zero is a defined operation in this standard — it produces Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, or Double.NaN depending on the operands. ArithmeticException is thrown only for integer and long division/modulo by zero, because integer arithmetic has no representation for infinity. This distinction appears in interview questions to test whether the candidate knows that 1.0 / 0.0 returns Infinity while 1 / 0 throws.

Q5. What causes UnsupportedOperationException when working with lists?

Three common sources: List.of() creates a fully immutable list — no add, remove, or set; Arrays.asList() creates a fixed-size list backed by the array — set() works (writes through to the array) but add() and remove() throw because they would change the size; and Collections.unmodifiableList() creates a read-only view where all mutating operations throw. The fix in all three cases: copy into a new ArrayList before mutating: new ArrayList<>(existingList).

Q6. What is ClassCastException and when does it occur?

ClassCastException is thrown when an object is cast to a type it is not an instance of — when object instanceof TargetType would return false. Common causes: casting an object from a raw-type collection (pre-generics code), incorrectly narrowing a supertype reference without checking with instanceof first, and deserialization producing the wrong type. Prevention: always use instanceof before casting, use generics to avoid raw types, and in modern Java use pattern matching (if (shape instanceof Circle c) { c.radius(); }) which combines the check and cast in one expression.

FAQs

Which Java exception is most common in production?

NullPointerException is consistently the most frequently encountered exception in Java applications. Studies of production Java logs across large codebases place it as the leading exception by volume. Java 14's helpful NPE messages — which name the null variable directly — significantly reduced the debugging time for NPEs in modern codebases.

Can ArithmeticException occur with floating-point division?

No. Floating-point division by zero follows IEEE 754 and returns Infinity or NaN — it never throws. ArithmeticException is exclusive to integer and long division and modulo operations (5 / 0 or 5 % 0). To check for problematic floating-point results use Double.isInfinite(value) and Double.isNaN(value).

Why does Arrays.asList() allow set() but not add() or remove()?

Arrays.asList() returns a List backed by the original array. Arrays have a fixed size — you can replace an element at an existing index, but you cannot add more slots or remove slots. set() changes the value at an existing index, which is valid — it writes through to the backing array. add() and remove() would change the length of the list, which is structurally impossible for an array-backed list of fixed size.

What is the difference between IndexOutOfBoundsException and ArrayIndexOutOfBoundsException?

ArrayIndexOutOfBoundsException is a subclass of IndexOutOfBoundsException. ArrayIndexOutOfBoundsException is thrown specifically by array access operations when the index is out of range. IndexOutOfBoundsException (or its other subclass StringIndexOutOfBoundsException) is thrown by List.get(), String.charAt(), and similar indexed operations. When catching bounds errors generically, catch IndexOutOfBoundsException — it handles all index-based access failures.

What is a helpful NullPointerException and which Java version introduced it?

Java 14 introduced detailed NPE messages that describe exactly which part of an expression was null. For example: Cannot invoke "String.toUpperCase()" because the return value of "UserProfile.address()" is null tells you address() returned null — not just that a NPE occurred somewhere. This feature is enabled by default in Java 14 and eliminates much of the guesswork when an NPE occurs in a chained expression.

How do I read a Java stack trace to find which exception occurred and where?

Read the stack trace from top to bottom. The first line names the exception class and its message — java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null. The lines below (beginning with at) are the call frames from where the exception was thrown down to where execution started. The top frame (at com.example.OrderService.validate(OrderService.java:42)) is where the exception originated — start debugging there. If the exception was wrapped, look for Caused by: further down — that shows the root cause thrown before the wrapper.

Summary

The common Java exceptions form a recognisable vocabulary. NullPointerException — null dereference, prevented with null checks, Optional, and getOrDefault. ArrayIndexOutOfBoundsException — off-by-one in index math, prevented with for-each. ClassCastException — invalid cast, prevented with instanceof before casting. NumberFormatException — non-numeric string, prevented by validating before parsing. ConcurrentModificationException — structural change during iteration, fixed by removeIf or iterator.remove(). UnsupportedOperationException — mutating an immutable or fixed-size view, fixed by copying first.

For interviews, know the root cause of each, know the one-line prevention for each, and know which ones are unchecked (all of the above) versus checked (IOException, SQLException). The question "what causes ConcurrentModificationException" is among the most frequently asked in Java collections interviews at both service and product companies.

What to Read Next

Topic	Link
The complete exception handling foundation — try, catch, finally, throw, and throws	Java Exception Handling →
How try, catch, and finally work together with all sequencing rules	Java try-catch →
The difference between checked and unchecked exceptions with design guidance	Java Checked vs Unchecked Exceptions →
How to design custom exception classes for your domain with the right fields	Java Custom Exceptions →
How throw and throws differ and how the declaration propagates through method signatures	Java throw and throws →

←

PreviousChecked vs Unchecked Exceptions

Nexttry-catch

→