Java中优雅处理链式操作的Optional结果与短路逻辑

public class CommandExecutor {

    // 模拟执行命令的方法，返回Optional<Integer>：
    // 如果命令成功，返回Optional.empty()；
    // 如果命令失败，返回包含错误码的Optional<Integer>。
    public Optional<Integer> executeCmd(String command) {
        System.out.println("Executing: " + command);
        // 模拟命令执行结果
        if (command.contains("fail")) {
            return Optional.of(1); // 模拟失败
        }
        if (command.contains("critical")) {
            return Optional.of(2); // 模拟更严重的失败
        }
        return Optional.empty(); // 模拟成功
    }

    public int topMethod() {
        int cr = execCmds();
        System.out.println("Final return code: " + cr);
        return cr;
    }

    private int execCmds() {
        // 这种方式是无效的，因为Lambda表达式中不能直接返回外部方法的值
        // executeCmd("my command").ifPresent(cr -> return cr);
        // executeCmd("my next command").ifPresent(cr -> return cr);
        // ...
        return 0; // 默认成功
    }
}

import java.util.Optional;

public class CommandExecutor {

    public Optional<Integer> executeCmd(String command) {
        System.out.println("Executing: " + command);
        if (command.contains("fail")) {
            return Optional.of(1);
        }
        if (command.contains("critical")) {
            return Optional.of(2);
        }
        return Optional.empty();
    }

    public int topMethod() {
        int cr = execCmds();
        System.out.println("Final return code: " + cr);
        return cr;
    }

    private int execCmds() {
        return executeCmd("first command") // 尝试执行第一个命令
                .or(() -> executeCmd("second command")) // 如果第一个命令成功，则不执行此Supplier
                .or(() -> executeCmd("third command - fail")) // 如果第二个命令成功，则不执行此Supplier
                .or(() -> executeCmd("fourth command")) // 如果第三个命令失败，则会执行此Supplier
                .orElse(0); // 如果所有命令都成功（都返回Optional.empty()），则最终返回0
    }

    public static void main(String[] args) {
        CommandExecutor executor = new CommandExecutor();
        executor.topMethod(); // 示例调用
        System.out.println("--- Another Run ---");
        executor.executeCmd("only one critical command").orElse(0); // 模拟单个命令执行
        System.out.println("--- Another Run with early exit ---");
        executor.execCmds(); // 再次调用，观察短路效果
    }
}

import java.util.Optional;
import java.util.OptionalInt;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class CommandExecutor {

    // 模拟执行命令的方法，返回OptionalInt：
    // 如果命令成功，返回OptionalInt.empty()；
    // 如果命令失败，返回包含错误码的OptionalInt。
    public OptionalInt executeCmdWithInt(String command) {
        System.out.println("Executing: " + command);
        if (command.contains("fail")) {
            return OptionalInt.of(1);
        }
        if (command.contains("critical")) {
            return OptionalInt.of(2);
        }
        return OptionalInt.empty();
    }

    public int topMethodStream() {
        int cr = execCmdsStream();
        System.out.println("Final return code (Stream): " + cr);
        return cr;
    }

    private int execCmdsStream() {
        return Stream.<Supplier<OptionalInt>>of( // 创建一个Supplier的流
                        () -> executeCmdWithInt("first command"),
                        () -> executeCmdWithInt("second command"),
                        () -> executeCmdWithInt("third command - fail"),
                        () -> executeCmdWithInt("fourth command")
                )
                .map(Supplier::get)              // 执行每个Supplier，得到OptionalInt流
                .filter(OptionalInt::isPresent)  // 过滤掉空的OptionalInt（成功的命令）
                .mapToInt(OptionalInt::getAsInt) // 将非空的OptionalInt转换为IntStream
                .findFirst()                     // 找到第一个非空OptionalInt（第一个失败的命令）
                .orElse(0);                      // 如果没有找到，则返回0（所有命令成功）
    }

    public static void main(String[] args) {
        CommandExecutor executor = new CommandExecutor();
        executor.topMethodStream(); // 示例调用
    }
}