如何按顺序执行带自定义名称的Map中CheckedRunnable步骤

要同时满足顺序执行和避免重复写构造器的需求，推荐用静态工厂方法+List/可变参数的组合，既保留顺序性，又简化步骤定义的写法。以下是几种可行实现：

方案1：静态工厂方法+内部类（兼容所有Java版本） #

通过给步骤类添加静态工厂方法，替代直接调用new构造器，同时用List保证执行顺序：

import net.jodah.failsafe.function.CheckedRunnable;
import java.util.List;

public class Test {
    // 封装步骤的内部类，构造器私有，强制通过静态方法创建
    static class Substep {
        String name;
        CheckedRunnable runnable;
        
        private Substep(String name, CheckedRunnable runnable) {
            this.name = name;
            this.runnable = runnable;
        }

        // 静态工厂方法，语义化命名，避免显式new
        public static Substep step(String name, CheckedRunnable runnable) {
            return new Substep(name, runnable);
        }
    }

    static void runSomeStuff(List<Substep> actions) {
        actions.forEach(substep -> {
            // 共享前置逻辑
            System.out.println("Running " + substep.name + "...");
            try {
                substep.runnable.run();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
            // 共享后置逻辑
        });
    }

    public static void main(String[] args) {
        runSomeStuff(List.of(
                Substep.step("Step 1", () -> System.out.println("1")),
                Substep.step("Step 2", () -> System.out.println("2"))
        ));
    }
}

方案2：Java 16+ 记录类（更简洁的封装） #

如果使用Java 16及以上，可利用记录类自动封装字段和构造器，再配合静态工厂方法进一步简化：

import net.jodah.failsafe.function.CheckedRunnable;
import java.util.List;

public class Test {
    // 记录类自动生成构造器、getter、equals/hashCode等
    static record Substep(String name, CheckedRunnable runnable) {
        // 可选：静态工厂方法，让调用更语义化
        public static Substep step(String name, CheckedRunnable runnable) {
            return new Substep(name, runnable);
        }
    }

    static void runSomeStuff(List<Substep> actions) {
        actions.forEach(substep -> {
            System.out.println("Running " + substep.name() + "...");
            try {
                substep.runnable().run();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        });
    }

    public static void main(String[] args) {
        runSomeStuff(List.of(
                Substep.step("Step 1", () -> System.out.println("1")),
                // 也可以直接用记录类构造，写法同样简洁
                new Substep("Step 2", () -> System.out.println("2"))
        ));
    }
}

方案3：可变参数方法（调用更直观） #

将执行方法改为接受可变参数，省去List.of()的包装，让步骤定义更紧凑：

import net.jodah.failsafe.function.CheckedRunnable;
import java.util.Arrays;

public class Test {
    static class StepPair {
        String name;
        CheckedRunnable runnable;
        
        private StepPair(String name, CheckedRunnable runnable) {
            this.name = name;
            this.runnable = runnable;
        }

        public static StepPair step(String name, CheckedRunnable runnable) {
            return new StepPair(name, runnable);
        }
    }

    // 直接接受多个步骤参数
    static void runSomeStuff(StepPair... steps) {
        Arrays.stream(steps).forEach(pair -> {
            System.out.println("Running " + pair.name + "...");
            try {
                pair.runnable.run();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        });
    }

    public static void main(String[] args) {
        runSomeStuff(
                StepPair.step("Step 1", () -> System.out.println("1")),
                StepPair.step("Step 2", () -> System.out.println("2"))
        );
    }
}

为什么之前的LinkedHashMap方案不可行？ #

你尝试改用LinkedHashMap时遇到的Target type of a lambda conversion must be an interface错误，原因是：

1. Map.of()返回的是JDK内部的不可变HashMap实现，无法强制转换为LinkedHashMap；
2. 即使手动创建LinkedHashMap，写法也非常繁琐（比如双括号初始化有内存泄漏风险），且可读性不如List+静态工厂的方案：

   // 不推荐的写法
   runSomeStuff(new LinkedHashMap<>() {{
       put("Step 1", () -> System.out.println("1"));
       put("Step 2", () -> System.out.println("2"));
   }});
   

内容的提问来源于stack exchange，提问作者Agustín