Question

我目前正在以下列方式创建整数常量。

public class Constants {
public static int SIGN_CREATE=0;
public static int SIGN_CREATE=1;
public static int HOME_SCREEN=2;
public static int REGISTER_SCREEN=3;
}

当我尝试以枚举方式执行此操作时

public enum PAGE{SIGN_CREATE,SIGN_CREATE,HOME_SCREEN,REGISTER_SCREEN}

当我使用PAGE.SIGN_CREATE时，它应该返回1;

Answer 1

嗯，你不可能那样做。 PAGE.SIGN_CREATE永远不会返回1;它将返回PAGE.SIGN_CREATE。这就是枚举类型的重点。

但是，如果您愿意添加几个按键，可以在枚举中添加字段，如下所示：


    public enum PAGE{
        SIGN_CREATE(0),
        SIGN_CREATE_BONUS(1),
        HOME_SCREEN(2),
        REGISTER_SCREEN(3);

        private final int value;

        PAGE(final int newValue) {
            value = newValue;
        }

        public int getValue() { return value; }
    }

然后你致电PAGE.SIGN_CREATE.getValue()获得0。

Answer 2

想要与每个枚举值关联的整数常量的最常见的正当理由是与仍然需要这些整数的其他组件进行互操作（例如，您无法更改的序列化协议，或者枚举表示表中的列等等。）

在几乎所有情况下，我建议使用EnumMap代替。它可以更完整地分离组件，如果这是关注点，或者如果枚举表示列索引或类似的东西，您可以在以后轻松进行更改（或者甚至在运行时进行更改）。

 private final EnumMap<Page, Integer> pageIndexes = new EnumMap<Page, Integer>(Page.class);
 pageIndexes.put(Page.SIGN_CREATE, 1);
 //etc., ...

 int createIndex = pageIndexes.get(Page.SIGN_CREATE);

它通常也非常高效。

将这样的数据添加到枚举实例本身可能非常强大，但通常不会被滥用。

编辑：刚刚意识到Bloch在Effective Java / 2nd edition中解决了这个问题，在第33项：使用EnumMap而不是序数索引。

Answer 3

您可以使用ordinal。因此PAGE.SIGN_CREATE.ordinal()会返回1。

编辑：

执行此操作的唯一问题是，如果您添加，删除或重新排序枚举值，您将破坏系统。对于许多人来说，这不是问题，因为他们不会删除枚举，只会在末尾添加其他值。它也不比整数常量差，它也要求你不要重新编号。但是最好使用如下系统：

public enum PAGE{
  SIGN_CREATE0(0), SIGN_CREATE(1) ,HOME_SCREEN(2), REGISTER_SCREEN(3)

  private int id;

  PAGE(int id){
    this.id = id;
  }

  public int getID(){
    return id;
  }

}

然后您可以使用getID。因此PAGE.SIGN_CREATE.getID()会返回1。

Answer 4

你可以将这个const值存储在枚举中，就像这样。但为什么甚至使用const？你坚持使用枚举吗？

public class SO3990319 {
   public static enum PAGE {
      SIGN_CREATE(1);
      private final int constValue;

      private PAGE(int constValue) {
         this.constValue = constValue;
      }

      public int constValue() {
         return constValue;
      }
   }

   public static void main(String[] args) {
      System.out.println("Name:    " + PAGE.SIGN_CREATE.name());
      System.out.println("Ordinal: " + PAGE.SIGN_CREATE.ordinal());
      System.out.println("Const:   " + PAGE.SIGN_CREATE.constValue());

      System.out.println("Enum: " + PAGE.valueOf("SIGN_CREATE"));
   }
}

修改

这取决于您使用的是什么来使用EnumMap或实例字段。

Bloch on Enum instance fields (Item 31: Use instance fields instead of ordinals)

Bloch on EnumMap (Item 33: Use EnumMap instead of ordinal indexing)

Answer 5

如果您希望能够将integer转换回具有所选值的相应enum，请参阅以下自动生成代码中的Constants.forValue(...)，但如果不是 BlairHippo的答案是最佳方式。

public enum Constants
{
SIGN_CREATE(0),
SIGN_CREATE(1),
HOME_SCREEN(2),
REGISTER_SCREEN(3);

    public static final int SIZE = java.lang.Integer.SIZE;

    private int intValue;
    private static java.util.HashMap<Integer, Constants> mappings;
    private static java.util.HashMap<Integer, Constants> getMappings()
    {
        if (mappings == null)
        {
            synchronized (Constants.class)
            {
                if (mappings == null)
                {
                    mappings = new java.util.HashMap<Integer, Constants>();
                }
            }
        }
        return mappings;
    }

    private Constants(int value)
    {
        intValue = value;
        getMappings().put(value, this);
    }

    public int getValue()
    {
        return intValue;
    }

    public static Constants forValue(int value)
    {
        return getMappings().get(value);
    }
}

Answer 6

我发现这有用：

http://dan.clarke.name/2011/07/enum-in-java-with-int-conversion/

public enum Difficulty
{
    EASY(0),
    MEDIUM(1),
    HARD(2);

    /**
    * Value for this difficulty
    */
    public final int Value;

    private Difficulty(int value)
    {
        Value = value;
    }

    // Mapping difficulty to difficulty id
    private static final Map<Integer, Difficulty> _map = new HashMap<Integer, Difficulty>();
    static
    {
        for (Difficulty difficulty : Difficulty.values())
            _map.put(difficulty.Value, difficulty);
    }

    /**
    * Get difficulty from value
    * @param value Value
    * @return Difficulty
    */
    public static Difficulty from(int value)
    {
        return _map.get(value);
    }
}

在java中以Enum方式将整数值存储为常量

6 个答案: