在java中以枚举方式将整数值存储为常量[重复]

你不能这么做。 PAGE.SIGN_CREATE 永远不会返回1;它将返回 PAGE.SIGN创建 . 这就是枚举类型的意义。

但是,如果您愿意添加一些击键,则可以将字段添加到枚举中,如下所示:

    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。

在几乎所有情况下,我建议使用 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);

它的效率也非常高。

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

编辑: 项目33:使用 而不是序数索引 .

你可以用 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个 .

您可以像这样将该常量值存储在枚举中。但为什么还要用警察呢?你在坚持枚举吗?

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"));
   }
}

这取决于您使用什么int来确定是使用EnumMap还是使用instance字段。

• Bloch on Enum instance fields (Item 31: Use instance fields instead of ordinals)
• Bloch on EnumMap (Item 33: Use EnumMap instead of ordinal indexing)

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);
    }
}

如果你想转换 integer 返回对应 enum 使用选定值请参见 Constants.forValue(...) 布莱希波 是最好的办法。

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);
    }
}