我有;
public enum Detailed {
PASSED, INPROCESS, ERROR1, ERROR2, ERROR3;
}
并需要将其转换为以下内容；
public enum Simple {
DONE, RUNNING, ERROR;
}
所以首先PASSED->DONE和INPROCESS-> RUNNING，但所有错误都应该是：ERROR. 显然可以为所有值编写案例，但可能有更好的解决方案？
问问题
46908 次
7 回答
35
就我个人而言，我只会创建一个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 使用多态的方法更简单，因为我们并没有真正尝试提供不同的行为——只是不同的简单映射。）
虽然您可能会用序数值做一些狡猾的事情，但它会不那么明显，并且需要更多的代码 - 我认为没有任何好处。
于 2012-06-18T05:49:47.093 回答
31
一种方法是asSimple()在Detailed枚举中定义一个方法：
public enum Detailed {
PASSED {
@Override
Simple asSimple() {
return DONE;
}
},
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。这可能是也可能不是坏事，具体取决于您的系统架构。
于 2012-06-18T05:48:12.630 回答
10
使用枚举映射
我通过实现转换服务将外部 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);
}
...
}
于 2014-12-05T08:22:02.353 回答
2
番石榴Enums.getIfPresent()开着Enum.name()
我们的案例是这个案例的一个特殊专业。我们确实有两个Enum：一个在应用程序中使用，另一个在核心库中使用。核心库被不同团队的少数应用程序使用。每个应用程序都查看整个功能的一个子集。整个功能都使用枚举进行配置，以便打开和关闭、加速或减速、选择策略等。
所以我们最终得到：
- 库的一个枚举，包含所有可能的配置，从应用程序可见，还有一些特定于库的
- 每个应用程序一个枚举，包含与应用程序在库中可以看到/触摸的内容相对应的文字，以及一些特定于应用程序的
然后，当我们将数据向下传递到库时，我们会调整所有数据以及这些配置。我们拥有所有枚举，因此我们可以选择在不同的枚举中使用相同的文字调用相同的配置。
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()fromcom.google.common.base.Enums方法：
Aplication1Config config1App1 = FUNCTION_TWO;
LibraryConfig configLib = Enums.getIfPresent(LibraryConfig.class, config1App1.name()).orNull();
我们检查configLib值null以查看是否成功转换。我们使用这最后一步是因为 APPX_FUNCTION_YYY，它是特定于应用程序的，并且用于方向 lib --> app 上的转换，而不是传递特定于库的配置值（FUNCTION_FOUR在示例中）。
maven的依赖管理：
以防万一有人需要它：
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>20.0</version>
</dependency>
国产版：
您可以使用 Enum 方法进行自己的转换，但您必须注意异常以检测何时转换不成功：
try {
Aplication1Config config1App1 = FUNCTION_TWO;
LibraryConfig configLib = LibraryConfig.valueOf(config1App1.name());
} catch (IllegalArgumentException iae) {
// if the conversion did not succeed
}
于 2019-01-25T12:31:27.593 回答
1
Ted 的回答非常Javaly，但表达式
passed == PASSED ? DONE : ERROR
也会做这项工作。
于 2012-06-18T05:52:39.187 回答
0
对我来说，这听起来更像是一个概念问题而不是编程问题。为什么不直接删除“简单”枚举类型并在程序的所有位置使用另一种类型呢？
只是为了让另一个例子更清楚：你真的会尝试为一周中的工作日（周一到周五）定义一个枚举类型，并为一周中的所有天（周一到周日）定义另一个枚举吗？
于 2012-06-18T05:54:29.773 回答
0
这是带有测试的简单枚举映射器：
- 执行
-- 枚举
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;
}
}
--映射器
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);
}
}
}
- 测试
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));
}
}
于 2015-01-15T21:30:46.923 回答