Java 基于枚举创建枚举类别

我有多个状态存储在一个枚举中

public enum Status {
    IS_A("isA"),
    IS_B("isB"),
    FP_ERR("fp_err"),
    FP_BLAH("fp_blah"),
    CORRECT("correct")

    private final String value;

    Status(String value) {
        this.value = value;
    }
}

我希望按照以下方式基于这些状态创建类别，而无需修改Status enum类

public enum Category {
    CategoryA("CategoryA",Status.IS_A, Status.IS_B),
    CategoryB("CategoryB",Status.FP_ERR, Status.FP_BLAH).
    CategoryC("CategoryC",Status.Correct);

    private List<Status> status;
    private String category;

    private static final Map<Status, String> VALUE_MAP = Stream.of(Category.values()) 

    Category(String category, Status ... status) {
        this.status = Arrays.asList(status);
        this.category = category;
    }

    public static String getCategory(Status status) {
        //Retrun category based on Status type
        String category = VALUE_MAP.get(status);
        return category;
    }
}

公共枚举类别{
类别（“类别”，状态为A，状态为B），
CategoryB（“CategoryB”，Status.FP_ERR，Status.FP_BLAH）。
CategoryC（“CategoryC”，Status.Correct）；
私人名单状态；
私有字符串类别；
私有静态最终映射值\u Map=Stream.of（Category.values（））
类别（字符串类别、状态…状态）{
this.status=Arrays.asList（status）；
this.category=类别；
}
公共静态字符串getCategory（状态）{
//基于状态类型重新运行类别
字符串category=VALUE\u MAP.get（状态）；
退货类别；
}
}

---

我无法确定如何将每个类别的值及其状态存储在映射值映射中，您根本不需要

值映射。当通过
Status
检索
category
时，您只需浏览所有
category.values（）
并找到包含请求的
状态的值：

public static String getCategory(Status status) {
    for (Category category : values()) {
        if (category.status.contains(status)) {
            return category.category;
        }
    }
    return null;
}

您根本不需要
VALUE\u MAP
。当通过
Status
检索
category
时，您只需浏览所有
category.values（）
并找到包含请求的
状态的值：

public static String getCategory(Status status) {
    for (Category category : values()) {
        if (category.status.contains(status)) {
            return category.category;
        }
    }
    return null;
}

如果将初始化更改为
静态
块，则可以执行以下操作：

private static final EnumMap<Status, String> VALUE_MAP = new EnumMap<>(Status.class);
static {
    Arrays.stream(Category.values()).forEach(category -> {
        category.status.forEach(status -> {
            VALUE_MAP.put(status, category.category);
        });
    });
}

private static final EnumMap VALUE\u MAP=new EnumMap（Status.class）；
静止的{
Arrays.stream（Category.values（））.forEach（Category->{
category.status.forEach（状态->{
价值映射放置（状态、类别、类别）；
});
});
}
如果将初始化更改为
静态
块，则可以执行以下操作：

private static final EnumMap<Status, String> VALUE_MAP = new EnumMap<>(Status.class);
static {
    Arrays.stream(Category.values()).forEach(category -> {
        category.status.forEach(status -> {
            VALUE_MAP.put(status, category.category);
        });
    });
}

private static final EnumMap VALUE\u MAP=new EnumMap（Status.class）；
静止的{
Arrays.stream（Category.values（））.forEach（Category->{
category.status.forEach（状态->{
价值映射放置（状态、类别、类别）；
});
});
}
这比使用
Map
的效率要低。不，如果enum中只有3个值。如果
Map
是
HashMap
，效率差异很难说，但不管出于什么原因，人们似乎总是忽略
EnumMap
的存在，设计用于将
enum
键映射到一个值，因此肯定比嵌套循环更有效（请注意
列表上的
包含
也是一个线性搜索）…这比使用
Map
效率低。不，如果enum中只有3个值。效率差异很难说，如果
Map
是一个
HashMap
，但不管出于什么原因，人们似乎总是忽略
EnumMap
的存在，它是为将
enum
键映射到一个值而设计的，因此肯定比嵌套循环更有效（请注意
列表中包含
也是一个线性搜索）…您应该使用
EnumMap
而不是
HashMap
。否则，这是一个很好的建议。首先尝试在不使用
forEach
的情况下找到解决方案，例如
私有静态最终映射值\u Map=Arrays.stream（values（））.collect（（）->new EnumMap（Status.class），（m，c）->c.Status.forEach（s->m.put（s，c.category）），Map:：putAll）
应该使用
EnumMap
而不是
HashMap
。否则，这是一个很好的建议。首先尝试在不使用
forEach
的情况下找到解决方案，例如
私有静态最终映射值\u Map=Arrays.stream（values（））.collect（（）->new EnumMap（Status.class），（m，c）->c.Status.forEach（s->m.put（s，c.category）），Map:：putAll）