Exception Handling

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();\
map.put("A\

CompletableFuture.supplyAsync(() -> {\
    if (true) throw new RuntimeException("Async task failed");\
    return "Success";\
}).exceptionally(ex -> {\
    System.err.println("Handled async failure: " + ex.getMessage());\
    return "Fallback Value";\
}).thenAccept(System.out.println);

try {\
    Class<?> clazz = Class.forName("com.missing.Driver");\
} catch (ClassNotFoundException e) {\
    System.out.println("Class not found on classpath: " + e.getMessage());\
}

// GOOD practice:\
try {\
    service.execute();\
} catch (DataAccessException e) {\
    logger.error("Failed to process operation for user: {}\
}

// StackOverflowError example:
void recursive() {
    recursive();
}

// OutOfMemoryError example:
void fillHeap() {
    List<byte[]> memory = new ArrayList<>();
    while(true) memory.add(new byte[10_000_000]);
}

List<String> list = new ArrayList<>(List.of("A\

Object obj = "Hello Java";\
// Safe casting using pattern matching\
if (obj instanceof String s) {\
    System.out.println(s.toUpperCase());\
} else {\
    System.out.println("Not a String");\
}

public void process() throws IOException, SQLException {\
    try {\
        if (Math.random() > 0.5) throw new IOException("IO error");\
        else throw new SQLException("DB error");\
    } catch (Exception e) {\
        // Precise rethrow tracks actual checked exception types\
        throw e;\
    }\
}

Thread thread = new Thread(() -> {\
    throw new RuntimeException("Unexpected worker crash");\
});\
thread.setUncaughtExceptionHandler((t

try {\
    int data = 10 / 0;\
} catch (ArithmeticException e) { // Specific subclass first\
    System.out.println("Arithmetic failure: " + e.getMessage());\
} catch (Exception e) {            // General superclass last\
    System.out.println("General failure: " + e.getMessage());\
}

class Parent {
    void process() throws IOException {}
}
class Child extends Parent {
    @Override
    void process() throws FileNotFoundException {} // Valid: narrower checked exception
}

class Exam {\
    private boolean started;\
\
    void submit() {\
        if (!started) {\
            throw new IllegalStateException("Exam has not started");\
        }\
        System.out.println("Exam submitted");\
    }\
}

public void setPercentage(double val) {\
    if (val < 0.0 || val > 100.0) {\
        throw new IllegalArgumentException("Percentage must be between 0 and 100");\
    }\
}

public static int testMethod() {\
    try {\
        throw new RuntimeException("Error");\
    } finally {\
        return 42; // Swallows the RuntimeException and returns 42!\
    }\
}

try {\
    System.out.println("Executing task");\
    System.exit(0);\
} finally {\
    // This block will NOT be executed!\
    System.out.println("Cleanup code");\
}

try (BadResource resource = new BadResource()) {\
    throw new RuntimeException("Primary failure");\
} catch (Exception e) {\
    System.out.println("Primary: " + e.getMessage());\
    for (Throwable suppressed : e.getSuppressed()) {\
        System.out.println("Suppressed: " + suppressed.getMessage());\
    }\
}

try {\
    database.connect();\
} catch (SQLException e) {\
    throw new ServiceException("Failed to initialize service layer\
}

public class OrderNotFoundException extends RuntimeException {
    public OrderNotFoundException(String message) {
        super(message);
    }
    public OrderNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
}

try {\
    Class<?> clazz = Class.forName("com.example.Service");\
    clazz.getMethod("execute").invoke(null);\
} catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException e) {\
    System.out.println("Reflective operation failed: " + e.getMessage());\
}

void validateBalance(double amount) throws InsufficientBalanceException {\
    if (amount <= 0) {\
        throw new IllegalArgumentException("Amount must be positive");\
    }\
    if (amount > balance) {\
        throw new InsufficientBalanceException("Insufficient funds");\
    }\
}

try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {\
    System.out.println(br.readLine());\
} catch (IOException e) {\
    System.out.println("Error reading file: " + e.getMessage());\
}

FileInputStream fis = null;\
try {\
    fis = new FileInputStream("test.txt");\
} catch (FileNotFoundException e) {\
    System.out.println("File not found");\
} finally {\
    if (fis != null) {\
        try { fis.close(); } catch (IOException ignored) {}\
    }\
}

// Error handling is generally avoided:\
try {\
    recursiveMethod();\
} catch (StackOverflowError e) {\
    System.err.println("Call stack overflow occurred: " + e.getMessage());\
}

static String readFile() throws IOException {\
    return Files.readString(Path.of("data.txt"));\
}\
\
static void setAge(int age) {\
    if (age < 0) {\
        throw new IllegalArgumentException("Age cannot be negative");\
    }\
}

try {
    processOrder(order);
} catch (OrderProcessingException e) {
    logger.error(
        "Order processing failed for orderId={}\
}

try {
    inventoryClient.reserve(order);
} catch (HttpServerErrorException e) {
    throw new InventoryServiceException(
        "Inventory service is unavailable\
}

reserveInventory(order);

try {
    chargePayment(order);
} catch (PaymentException e) {
    releaseInventory(order); // Compensation
    throw e;
}

@Transactional
public void createOrder(Order order) {
    saveOrder(order);
    saveOrderItems(order);
    reserveInventory(order);

    // A failure should prevent an invalid partial transaction
    // from being committed.
}

String requestId = "PAY-12345";

try {
    paymentClient.charge(requestId
}

try {
    validateExam(exam);
} catch (InvalidExamException e) {
    // Do not retry invalid business input.
    throw e;
}