Java中如何为Enum枚举的单个值设置多个优先级？

以下两种方案都可以满足需求，可根据业务场景选择：

方案1：动态优先级计算（推荐） #

X的优先级本质和跳转前的源状态绑定，不需要硬存储多组固定优先级，通过动态方法获取即可，兼容原有逻辑的同时规则可统一维护：

public enum States {
    A(0), B(1), C(2), D(3), E(4), X(-1); // X默认优先级设为无效值，强制走动态获取逻辑

    private final int basePriority;
    // 统一维护所有合法状态跳转映射
    private static final Map<States, Set<States>> ALLOWED_TRANSITIONS = Map.of(
        A, Set.of(B, X),
        B, Set.of(C, X),
        C, Set.of(D, X),
        D, Set.of(E, X),
        E, Set.of(),
        X, Set.of()
    );

    States(int basePriority) {
        this.basePriority = basePriority;
    }

    // 对外暴露优先级获取方法，传入跳转前的源状态
    public int getPriority(States sourceState) {
        // 非X状态直接返回自身固定优先级，兼容旧代码
        if (this != X) {
            return this.basePriority;
        }
        // 校验跳转合法性后返回对应优先级，可自定义计算规则
        if (ALLOWED_TRANSITIONS.get(sourceState).contains(X)) {
            // 示例为直接复用源状态优先级，需要调整计算逻辑直接修改此处即可
            return sourceState.basePriority;
        }
        throw new IllegalArgumentException("非法跳转：无法从" + sourceState + "跳转至X");
    }

    // 可选：新增跳转合法性校验方法，避免业务代码硬编码判断
    public boolean canTransitionTo(States target) {
        return ALLOWED_TRANSITIONS.get(this).contains(target);
    }
}

该方案优势：无冗余存储、状态流转规则内聚、后续调整优先级规则或者新增状态的维护成本极低。

方案2：硬编码多组优先级 #

如果业务要求X的优先级为固定多组值、和源状态无统一计算规则，可以将优先级字段修改为集合类型存储多值：

public enum States {
    A(List.of(0)),
    B(List.of(1)),
    C(List.of(2)),
    D(List.of(3)),
    E(List.of(4)),
    // 按业务需求配置X的多组优先级，示例为对应A/B/C/D跳转的优先级
    X(List.of(0, 1, 2, 3));

    private final List<Integer> priorities;

    States(List<Integer> priorities) {
        this.priorities = priorities;
    }

    // 兼容旧代码的单优先级获取方法
    public int getSinglePriority() {
        return priorities.get(0);
    }

    // X状态根据源状态获取对应优先级
    public int getPriorityBySource(States source) {
        if (this != X) {
            return getSinglePriority();
        }
        return switch (source) {
            case A -> priorities.get(0);
            case B -> priorities.get(1);
            case C -> priorities.get(2);
            case D -> priorities.get(3);
            default -> throw new IllegalArgumentException("不支持的源状态");
        };
    }
}

该方案适用场景：X的多优先级需要自定义配置、无统一计算规则的场景。

内容的提问来源于stack exchange，提问作者T.P.