如何在java中将一个枚举转换为另一个枚举？

时间：2012-06-18 05:43:23

标签： java enums

我有; 

public enum Detailed {
    PASSED, INPROCESS, ERROR1, ERROR2, ERROR3;
}

并需要将其转换为以下内容; 

public enum Simple {
    DONE, RUNNING, ERROR;
}

首先PASSED - ＆gt; DONE和INPROCESS - ＆gt; RUNNING，但所有错误都应为：ERROR。显然，可以为所有值编写案例，但可能有更好的解决方案吗？

7 个答案:

答案 0 :(得分：25)

就个人而言，我只想创建一个Map<Detailed, Simple>并明确地执行此操作 - 甚至可能使用switch语句。

另一种选择是将映射传递给构造函数 - 当然，你只能单向循环：

public enum Detailed {
    PASSED(Simple.DONE),
    INPROCESS(Simple.RUNNING),
    ERROR1(Simple.ERROR),
    ERROR2(Simple.ERROR),
    ERROR3(Simple.ERROR);

    private final Simple simple;

    private Detailed(Simple simple) {
        this.simple = simple;
    }

    public Simple toSimple() {
        return simple;
    }
}

（我觉得这比Ted使用多态的方法更简单，因为我们并没有真正尝试提供不同的行为 - 只是一个不同的简单映射。）

虽然可能可能会使用序数值做一些狡猾的事情，但它会更不明显，并且需要更多代码 - 我认为没有任何好处。

答案 1 :(得分：23)

一种方法是在asSimple()枚举中定义方法Detailed：

public enum Detailed {
    PASSED {
        @Override
        Simple asSimple() {
            return PASSED;
        }
    },
    INPROCESS {
        @Override
        Simple asSimple() {
            return RUNNING;
        }
    },
    ERROR1,
    ERROR2,
    ERROR3;
    public Simple asSimple() {
        return Simple.ERROR; // default mapping
    }
}

然后，您可以在想要进行映射时简单地调用该方法：

Detailed code = . . .
Simple simpleCode = code.asSimple();

它的优势在于将映射的知识与Detailed枚举（可能属于它）放在一起。它的缺点是知道Simple与Detailed的代码混合在一起。这可能是坏事，也可能不是坏事，具体取决于您的系统架构。

答案 2 :(得分：9)

使用EnumMap

我通过实现转换服务将外部xml接口与内部域模型分离。这包括将jaxb生成的代码中的枚举映射到域模型枚举。

使用静态EnumMap封装了负责转换的类中转换的关注点。它的凝聚力。 

@Service
public class XmlTransformer {

    private static final Map<demo.xml.Sense, Constraint.Sense> xmlSenseToSense;
    static {
        xmlSenseToSense = new EnumMap<demo.xml.Sense, Constraint.Sense> (
            demo.xml.Sense.class);
        xmlSenseToSense.put(demo.xml.planningInterval.Sense.EQUALS, 
            Constraint.Sense.EQUALS);
        xmlSenseToSense.put(demo.xml.planningInterval.Sense.GREATER_THAN_OR_EQUALS, 
            Constraint.Sense.GREATER_THAN_OR_EQUALS);
        xmlSenseToSense.put(demo.xml.planningInterval.Sense.LESS_THAN_OR_EQUALS, 
            Constraint.Sense.LESS_THAN_OR_EQUALS);
    }
    ...
}

答案 3 :(得分：1)

Ted的答案非常Javaly，但表达式

passed == PASSED ? DONE : ERROR

也会做这个工作。

答案 4 :(得分：0)

对我而言，这听起来更像是概念问题，而不是编程问题。为什么不直接删除“Simple”枚举类型并在程序的所有位置使用另一个？

只是为了让另一个例子更清楚：你真的会尝试为一周（星期一到星期五）的工作日定义枚举类型，并为一周的所有日子（星期一到星期日）定义另一个枚举吗？< / p>

答案 5 :(得分：0)

以下是带有test的简单枚举映射器：

- 实施

- ENUMS 

public enum FirstEnum {

A(0), B(1);

private final int value;

private FirstEnum(int value) {
    this.value = value;
}

public int getValue() {
    return value;
}
}

public enum  SecondEnum {

C(0), D(1);

private final int valueId;

private SecondEnum(int valueId) {
    this.valueId = valueId;
}

public int getValueId() {
    return valueId;
}

}

- MAPPER 

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang3.Validate;

import com.google.common.collect.Sets;

public class EnumPropertyMapping {

private final Map<?, ?> firstMap;
private final Map<?, ?> secondMap;

private final Class<?> firstType;
private final Class<?> secondType;

private EnumPropertyMapping(
        Map<?, ?> firstMap, Map<?, ?> secondMap, Class<?> firstType, Class<?> secondType) {

    this.firstMap = firstMap;
    this.secondMap = secondMap;
    this.firstType = firstType;
    this.secondType = secondType;
}

public static Builder builder() {
    return new Builder();
}

@SuppressWarnings("unchecked")
public <R> R getCorrespondingEnum(Object mappedEnum) {
    Validate.notNull(mappedEnum, "Enum must not be NULL");
    Validate.isInstanceOf(Enum.class, mappedEnum, "Parameter must be an Enum");

    if (firstType.equals(mappedEnum.getClass())) {
        return (R) firstMap.get(mappedEnum);
    }

    if (secondType.equals(mappedEnum.getClass())) {
        return (R) secondMap.get(mappedEnum);
    }

    throw new IllegalArgumentException("Didn't found mapping for enum value: " + mappedEnum);
}

public static class Builder {

    private final Map<Object, Object> firstEnumMap = new HashMap<>();
    private final Map<Object, Object> secondEnumMap = new HashMap<>();
    private Class<?> firstEnumType;
    private Class<?> secondEnumType;

    public <T extends Enum<T>> Builder addFirst(Class<T> enumType, String propertyName) {
        firstEnumType = enumType;
        initMap(firstEnumMap, enumType.getEnumConstants(), propertyName);
        return this;
    }

    public <T extends Enum<T>> Builder addSecond(Class<T> enumType, String propertyName) {
        secondEnumType = enumType;
        initMap(secondEnumMap, enumType.getEnumConstants(), propertyName);
        return this;
    }

    private void initMap(Map<Object, Object> enumMap, Object[] enumConstants, String propertyName) {
        try {
            for (Object constant : enumConstants) {
                enumMap.put(PropertyUtils.getProperty(constant, propertyName), constant);
            }
        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException ex) {
            throw new IllegalStateException(ex);
        }
    }

    public EnumPropertyMapping mapEnums() {
        Validate.isTrue(firstEnumMap.size() == secondEnumMap.size());
        Validate.isTrue(Sets.difference(firstEnumMap.keySet(), secondEnumMap.keySet()).isEmpty());

        Map<Object, Object> mapA = new HashMap<>();
        Map<Object, Object> mapB = new HashMap<>();

        for (Map.Entry<Object, Object> obj : firstEnumMap.entrySet()) {
            Object secondMapVal = secondEnumMap.get(obj.getKey());
            mapA.put(obj.getValue(), secondMapVal);
            mapB.put(secondMapVal, obj.getValue());
        }
        return new EnumPropertyMapping(mapA, mapB, firstEnumType, secondEnumType);
    }
}

}

- TEST 

import org.junit.Test;

import com.bondarenko.common.utils.lang.enums.FirstEnum;
import com.bondarenko.common.utils.lang.enums.SecondEnum;

import static junit.framework.TestCase.assertEquals;

public class EnumPropertyMappingTest {

@Test
public void testGetMappedEnum() {
    EnumPropertyMapping mapping = EnumPropertyMapping.builder()
                                                                                                     .addSecond(SecondEnum.class, "valueId")
                                                                                                     .addFirst(FirstEnum.class, "value")
                                                                                                     .mapEnums();

    assertEquals(SecondEnum.D, mapping.getCorrespondingEnum(FirstEnum.B));
    assertEquals(FirstEnum.A, mapping.getCorrespondingEnum(SecondEnum.C));
}

}

答案 6 :(得分：0)

番石榴Enums.getIfPresent()上的Enum.name()

我们的案例是该案例的一个特殊专业。我们确实有两个Enum：一个在应用程序中使用，另一个在核心库中使用。核心库供不同团队的少数应用程序使用。每个应用程序都查看整个功能的子集。整个功能都配置有枚举，以便打开和关闭，调高或调低，选择策略等。

所以我们最后得到了：

  1. 该库的一个枚举，包含从应用程序可见的所有可能的配置以及一些特定于库的
  2. 每个应用程序的一个枚举，包含与应用程序在库中可以看到/触摸的内容相对应的文字，以及一些特定于应用程序的

然后，当我们将数据向下传递到库时，我们将调整所有数据以及那些配置。我们拥有所有枚举，因此我们可以选择在不同的枚举中调用具有相同文字的相同配置。

Enum LibraryConfig {
    FUNCTION_ONE,
    FUNCTION_TWO,
    FUNCTION_THREE,
    FUNCTION_FOUR;
}

Enum Aplication1Config {
    FUNCTION_ONE,
    FUNCTION_TWO,
    FUNCTION_THREE,
    APPL1_FUNCTION_ONE,
    APPL1_FUNCTION_TWO;
}

Enum Aplication2Config {
    FUNCTION_ONE,
    FUNCTION_TWO,
    FUNCTION_FOUR;
    APPL2_FUNCTION_ONE;
}

当我们需要从一种类型转换为另一种类型（app-> lib或lib-> app）时，我们以这种方式使用getIfPresent()中的com.google.common.base.Enums方法：

Aplication1Config config1App1 = FUNCTION_TWO;
LibraryConfig configLib = Enums.getIfPresent(LibraryConfig.class, config1App1.name()).orNull();

我们检查configLib的{​​{1}}值，看是否转换成功。由于APPX_FUNCTION_YYY是特定于应用程序的，因此我们使用了最后一步，和用于在lib-> app方向上进行转换，而不传递特定于库的配置值（null在示例中）。

maven的依赖项管理：

以防万一有人需要它：

FUNCTION_FOUR

本地版本：

您可以使用Enum方法进行自己的转换，但是您必须照顾异常以检测何时转换失败：

    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>20.0</version>
    </dependency>
相关问题
最新问题