将枚举映射到java中代码量较少的另一个枚举

Question

我有两个枚举类，一个是外部的，另一个是内部的。

public enum ExternalEnum
{
  EXTERNAL_CAR, EXTERNAL_VAN, EXTERNAL_BUS
}

public enum InternalEnum
{
  CAR, VAN, BUS
}

我需要将内部映射到外部，外部映射到内部。所以我做了以下工作，

public class EnumMapper
{
  public ExternalEnum toExternal(InternalEnum internalEnum)
  {
    switch (internalEnum)
    {
    case BUS:
      return ExternalEnum.EXTERNAL_BUS;
    case CAR:
      return ExternalEnum.EXTERNAL_CAR;
    case VAN:
      return ExternalEnum.EXTERNAL_VAN;
    }
    return null;
  }

  public InternalEnum toInternal(ExternalEnum externalEnum)
  {
    switch (externalEnum)
    {
    case EXTERNAL_BUS:
      return InternalEnum.BUS;
    case EXTERNAL_CAR:
      return InternalEnum.CAR;
    case EXTERNAL_VAN:
      return InternalEnum.VAN;
    }
    return null;
  }
}

因此，相同类型的映射在两种方法中重复。难道没有一种很好的方法可以用更少的代码来实现这一点吗？

Answer 1

我能够通过使用BiMap以更少的代码量实现这一点。

import com.google.common.collect.EnumBiMap;

public class EnumBiMapMapper
{
  private EnumBiMap<InternalEnum, ExternalEnum> enumEnumBiMap = EnumBiMap.create(InternalEnum.class, ExternalEnum.class);

  public EnumBiMapMapper()
  {
    enumEnumBiMap.put(InternalEnum.BUS, ExternalEnum.EXTERNAL_BUS);
    enumEnumBiMap.put(InternalEnum.CAR, ExternalEnum.EXTERNAL_CAR);
    enumEnumBiMap.put(InternalEnum.VAN, ExternalEnum.EXTERNAL_VAN);
  }

  public ExternalEnum toExternal(InternalEnum internalEnum)
  {
    return enumEnumBiMap.get(internalEnum);
  }

  public InternalEnum toInternal(ExternalEnum externalEnum)
  {
    return enumEnumBiMap.inverse().get(externalEnum);
  }
}

Answer 2

Basil Bourque的答案很好，但我不喜欢使用序数（），因为您可以轻松地旋转枚举常量并且业务逻辑会被破坏。

您做得几乎正确，只需记住，常量是一个普通的旧java实例，可以通过其他功能进行扩展。因此，最好将所有映射器逻辑隐藏在枚举中。

public enum ExternalEnum {
    EXTERNAL_CAR,
    EXTERNAL_VAN,
    EXTERNAL_BUS
}

public enum InternalEnum {
    CAR(ExternalEnum.EXTERNAL_CAR),
    VAN(ExternalEnum.EXTERNAL_VAN),
    BUS(ExternalEnum.EXTERNAL_BUS);

    private final ExternalEnum externalEnum;

    InternalEnum(ExternalEnum externalEnum) {
        this.externalEnum = externalEnum;
    }

    public ExternalEnum toExternal() {
        return externalEnum;
    }

    public static Optional<InternalEnum> parseExternal(ExternalEnum externalEnum) {
        for (InternalEnum internalEnum : values())
            if (internalEnum.externalEnum == externalEnum)
                return Optional.of(internalEnum);
        return Optional.empty();
    }
}

演示

ExternalEnum externalEnum = ExternalEnum.EXTERNAL_CAR;
Optional<InternalEnum> optInternalEnum = InternalEnum.parseExternal(externalEnum);

System.out.println(externalEnum);
System.out.println(optInternalEnum.orElse(null));
System.out.println(optInternalEnum.map(InternalEnum::toExternal).orElse(null));

另一种方法是只使用映射器

public final class EnumMapper {
    
    private final Map<ExternalEnum, InternalEnum> MAP_EXT_INT = Map.of(
            ExternalEnum.EXTERNAL_CAR, InternalEnum.CAR,
            ExternalEnum.EXTERNAL_VAN, InternalEnum.VAN,
            ExternalEnum.EXTERNAL_BUS, InternalEnum.BUS);
            
    private final Map<InternalEnum, ExternalEnum> MAP_INT_EXT = Map.of(
            InternalEnum.CAR, ExternalEnum.EXTERNAL_CAR,
            InternalEnum.VAN, ExternalEnum.EXTERNAL_VAN,
            InternalEnum.BUS, ExternalEnum.EXTERNAL_BUS);
            
    public static ExternalEnum toExternal(InternalEnum internalEnum) {
        return MAP_INT_EXT.get(internalEnum);
    }
    
    public InternalEnum toInternal(ExternalEnum externalEnum) {
        return MAP_EXT_INT.get(externalEnum);
    }
    
    private EnumMapper() {}
}

public enum ExternalEnum {
    EXTERNAL_CAR,
    EXTERNAL_VAN,
    EXTERNAL_BUS
}

public enum InternalEnum {
    CAR,
    VAN,
    BUS;
}

Answer 3

InternalEnum.values()[ externalEnum.ordinal() ]

假设等效枚举对象以相同的顺序声明，我们可以通过访问从调用隐式public静态T[]value（）方法返回的所有枚举对象的数组来从另一个枚举对象中检索一个枚举对象（请参阅此问题）并通过从错误命名的Enum#顺序方法中检索的从零开始的索引号进行访问。

例如，<代码>内部枚举。values（）按声明顺序返回所有枚举对象的数组。然后，我们使用数组访问器来检索与另一个枚举中匹配的索引号相匹配的对象。

InternalEnum internalEnum = InternalEnum.values()[ externalEnum.ordinal() ] ;

反之亦然：

ExternalEnum externalEnum = ExternalEnum.values()[ internalEnum.ordinal() ] ;

这是示例用法。额外提示：在Java16中，我们可以在本地声明枚举——参见JEP 395：记录。

enum ExternalEnum { EXTERNAL_CAR, EXTERNAL_VAN, EXTERNAL_BUS }
enum InternalEnum { CAR, VAN, BUS }

System.out.println(
        InternalEnum.values()[ ExternalEnum.EXTERNAL_VAN.ordinal() ]
);

System.out.println(
        ExternalEnum.values()[ InternalEnum.VAN.ordinal() ]
);

厢式货车

EXTERNAL_VAN