Question

我正在寻找实现和访问我的枚举的方法，我对代码的外观不太满意。这似乎是一种补丁方式。所以这就是我要做的事情：

将这个简单的枚举视为我正在尝试做的一个例子：

public enum MyEnum {

  FIRST(0L), SECOND(1L), THIRD(2L);
  private Long number;

  private MyEnum(Long number){
    this.number= id;
  }

  public static boolean isFirst(MyEnum type) {
    return type == FIRST;
  }

  public static boolean isSecond(MyEnum type) {
    return type == SECOND;
  }

  public static boolean isThird(MyEnum type) {
    return type == THIRD;
  }

  public Long getId() {
    return number;
  }

}

稍后，我将一些对象设置为Long.valueOf（1L），并使用

将它们与此枚举进行比较

Long.valueOf(1L).equals(instanceOfMyEnum.getId())

我真的很讨厌在我的代码中使用那些硬编码的常量，所以我想知道使用这样的东西是不是一个坏习惯：

eMyEnum.FIRST.getId().equals(instanceOfMyEnum.getId())

或

someLongThatIPassAsParameter = eMyEnum.FIRST.getId();

这些只是一些简单的例子，但基本上它是一遍又一遍地重复的相同问题。你怎么看？

Answer 1

如果你有很多枚举值，我会做这样的事情（如果添加新代码则无需修改代码）：

public enum MyEnum {
    FIRST(0L), SECOND(1L), THIRD(2L);

    private Long number;

    /**
     * Lookup map, to provide a quick way to access your enums by id
     */
    private static final Map<Long, MyEnum> LOOKUP = new HashMap<Long, MyEnum>();

    /**
     * Static initializer, which loads your enums values runtime, and maps them
     * to their 'number' member.
     */
    static {
        MyEnum[] enums = MyEnum.class.getEnumConstants();
        for(MyEnum en : enums){
            LOOKUP.put(en.number, en);
        }
    }

    private MyEnum(final Long number) {
        this.number = number;
    }

    /**
     * Gets the enum value associated with the parameter, id.
     * @param id The id, that identifies your enum value
     * @return The enum value, or null, if not found.
     */
    public static MyEnum getById(final Long id){
        return LOOKUP.get(id);
    }
}

Answer 2

我不确定我是否正确理解了您的问题，但是如果使用开关检查这些检查呢？

 public enum MyEnum {

              FIRST(0L), SECOND(1L), THIRD(2L);
              private Long number;

              private static Map<Long, MyEnum> byIds = new HashMap<Long, PlaceServiceV2.MyEnum>();
              static{
                  for(MyEnum myEnum :MyEnum.values()){
                      byIds.put(myEnum.number, myEnum);
                  }

              }

              private MyEnum(Long number){
                this.number = number;   
              }

              public static MyEnum getById(Long id) {
                return byIds.get(id);
              }

              public Long getId() {
                return number;
         }
        }

public void test(){
    switch (MyEnum.getById(1L)) {
    case FIRST:

        break;
    case SECOND:

        break;

    default:
        break;
    }
}

Answer 3

为什么不在枚举

中实现fromLong方法

public static MyEnum fromLong(long l) {
    switch (l) {
    {
      case 0: return FIRST;
      case 1: return SECOND;
      case 2: return THIRD;
    }
    throw new IllegalArgumentException();
}

然后将long转换为枚举并比较枚举。所以你会：

MyEnum.fromLong(longValue) == MyEnum.FIRST

Answer 4

显然虽然你创建了一个枚举，但你仍然在各处使用这些Long值，所以也许你可以使用类似的东西：

public class TypeOfSomething {
    public static final long FIRST = 1l;
    public static final long ANALOG = 2l;
    public static final long USB = 3l;
}

然后使用它们：

someLongThatIPassAsParameter = TypeOfSomething.ANALOG;

枚举方式也很好，但我使用它以便在参数中使用枚举值更加舒适，而枚举中的值只是附加信息（例如用于国际化的messages.properties键）

以干净的方式使用<key，value =“”>枚举</key，>

4 个答案: