Java函数式编程如何处理嵌套异常？

import java.util.Optional;

public class NestedExceptionsWithOptional {

    public static void main(String[] args) {
        try {
            // 代码可能抛出异常
            String result = dangerousOperation();
            // 使用 Optional 处理潜在的异常
            Optional<String> optionalResult = Optional.ofNullable(result);
            System.out.println(optionalResult.orElse("默认值"));
        } catch (Exception e) {
            // 处理异常
            System.out.println("发生异常: " + e.getMessage());
        }
    }

    private static String dangerousOperation() {
        // 可能抛出异常的代码
        throw new RuntimeException("发生异常");
    }
}

import java.util.Optional;

public class NestedExceptionsWithTryCatch {

    public static void main(String[] args) {
        try {
            // 代码可能抛出异常
            String result = dangerousOperation();
            // 使用 try-catch 捕获潜在的异常
            try {
                System.out.println(result);
            } catch (Exception e) {
                // 处理嵌套异常
                System.out.println("发生嵌套异常: " + e.getMessage());
            }
        } catch (Exception e) {
            // 处理外部异常
            System.out.println("发生外部异常: " + e.getMessage());
        }
    }

    private static String dangerousOperation() {
        // 可能抛出异常的代码
        throw new RuntimeException("发生异常");
    }
}

import java.util.concurrent.CompletableFuture;

public class NestedExceptionsWithCompletableFuture {

    public static void main(String[] args) {
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            // 代码可能抛出异常
            return dangerousOperation();
        });

        // 使用 whenComplete 处理潜在的异常
        cf.whenComplete((result, ex) -> {
            if (ex != null) {
                // 处理嵌套异常
                System.out.println("发生嵌套异常: " + ex.getMessage());
            } else {
                System.out.println("结果: " + result);
            }
        });
    }

    private static String dangerousOperation() {
        // 可能抛出异常的代码
        throw new RuntimeException("发生异常");
    }
}

import java.util.Optional;

public class ParseIntegerExample {

    public static void main(String[] args) {
        String input = "123";

        // 使用 Optional 处理可能无法解析的整数
        Optional<Integer> optionalInteger = Optional.ofNullable(parseInt(input));

        // 通过使用 orElseGet 方法，确保总是返回一个整数
        int result = optionalInteger.orElseGet(() -> {
            // 发生异常时返回默认值
            System.out.println("无法解析整数，返回默认值");
            return 0;
        });

        System.out.println("解析结果: " + result);
    }

    private static Integer parseInt(String input) {
        try {
            // 可能抛出 NumberFormatException
            return Integer.parseInt(input);
        } catch (NumberFormatException e) {
            // 处理 NumberFormatException
            throw new RuntimeException("无法解析整数", e);
        }
    }
}