在Java枚举中使用==可以吗？

是否可以==在Java枚举中使用，还是需要使用.equals()？在我的测试中，它==始终有效，但是我不确定是否可以保证。特别是，.clone()在枚举上没有方法，因此我不知道是否有可能获得一个枚举，该枚举.equals()将返回不同于的值==。

例如，这样可以吗：

public int round(RoundingMode roundingMode) {
  if(roundingMode == RoundingMode.HALF_UP) {
    //do something
  } else if (roundingMode == RoundingMode.HALF_EVEN) {
    //do something
  }
  //etc
}

还是我需要这样写：

public int round(RoundingMode roundingMode) {
  if(roundingMode.equals(RoundingMode.HALF_UP)) {
    //do something
  } else if (roundingMode.equals(RoundingMode.HALF_EVEN)) {
    //do something
  }
  //etc
}

仅需2美分：这是Sun发布的Enum.java的代码，并且是JDK的一部分：

public abstract class Enum<E extends Enum<E>>
    implements Comparable<E>, Serializable {

    // [...]

    /**
     * Returns true if the specified object is equal to this
     * enum constant.
     *
     * @param other the object to be compared for equality with this object.
     * @return  true if the specified object is equal to this
     *          enum constant.
     */
    public final boolean equals(Object other) { 
        return this==other;
    }


}

是的，==很好-每个值都保证只有一个引用。

但是，有一种更好的编写舍入方法的方法：

public int round(RoundingMode roundingMode) {
  switch (roundingMode) {
    case HALF_UP:
       //do something
       break;
    case HALF_EVEN:
       //do something
       break;
    // etc
  }
}

甚至更好的做这件事的方式是把枚举本身的功能，所以你可以只调用roundingMode.round(someValue)。这是Java枚举的核心-它们是面向对象的枚举，与其他地方的“命名值”不同。

编辑：规范不是很清楚，但第8.9节指出：

枚举类型的主体可以包含枚举常量。枚举常量定义枚举类型的实例。枚举类型除了由其枚举常量定义的实例外，没有其他实例。

是的，就好像您已经为枚举中的每个值创建了单例实例一样：

公共抽象类RoundingMode {
  公共静态最终RoundingMode HALF_UP = new RoundingMode（）;
  公共静态最终RoundingMode HALF_EVEN = new RoundingMode（）;

  私人RoundingMode（）{
    //私有作用域可防止此类之外的任何子类型
  }
}

但是，该enum构造为您带来各种好处：

• 每个实例的toString（）打印代码中给定的名称。
• （如另一篇文章所述），可以使用switch-case控制结构将枚举类型的变量与常量进行比较。
• 可以使用values为每种枚举类型“生成” 的字段查询枚举中的所有值
• 这是最大的身份比较：枚举值可以在不克隆的情况下进行序列化。

序列化是一个很大的难题。如果我使用上面的代码而不是枚举，则身份相等的行为如下：

RoundingMode原始= RoundingMode.HALF_UP;
断言（RoundingMode.HALF_UP ==原始）; //通过

ByteArrayOutputStream baos = new ByteArrayOutputStream（）;
ObjectOutputStream oos =新的ObjectOutputStream（baos）;
oos.writeObject（原始）;
oos.flush（）;

ByteArrayInputStream bais = new ByteArrayInputStream（baos.toByteArray（））;
ObjectInputStream ois = new ObjectInputStream（bais）;
RoundingMode反序列化=（RoundingMode）ois.readObject（）;

断言（RoundingMode.HALF_UP ==反序列化）; //失败
断言（RoundingMode.HALF_EVEN ==反序列化）; //失败

您可以使用涉及writeReplace和的技术来解决此问题而无需枚举readResolve（请参阅http://java.sun.com/j2se/1.4.2/docs/api/java/io/Serializable.html）...

我想关键是-Java竭尽全力允许您使用枚举值的身份来测试相等性；这是一种鼓励的做法。

==比较两个对象的引用。对于枚举，可以保证只有一个实例，因此对于任何两个相同的枚举，==将为true。

参考：

http://www.ajaxonomy.com/2007/java/making-the-most-of-java-50-enum-tricks

（在Sun文档中找不到任何内容）

这是一些您可能会发现有趣的邪恶代码。：D

public enum YesNo {YES, NO}

public static void main(String... args) throws Exception {
    Field field = Unsafe.class.getDeclaredField("theUnsafe");
    field.setAccessible(true);
    Unsafe unsafe = (Unsafe) field.get(null);
    YesNo yesNo = (YesNo) unsafe.allocateInstance(YesNo.class);

    Field name = Enum.class.getDeclaredField("name");
    name.setAccessible(true);
    name.set(yesNo, "YES");

    Field ordinal = Enum.class.getDeclaredField("ordinal");
    ordinal.setAccessible(true);
    ordinal.set(yesNo, 0);

    System.out.println("yesNo " + yesNo);
    System.out.println("YesNo.YES.name().equals(yesNo.name()) "+YesNo.YES.name().equals(yesNo.name()));
    System.out.println("YesNo.YES.ordinal() == yesNo.ordinal() "+(YesNo.YES.ordinal() == yesNo.ordinal()));
    System.out.println("YesNo.YES.equals(yesNo) "+YesNo.YES.equals(yesNo));
    System.out.println("YesNo.YES == yesNo " + (YesNo.YES == yesNo));
}

枚举是阻塞多态代码的好地方。

enum Rounding {
  ROUND_UP {
    public int round(double n) { ...; }
  },
  ROUND_DOWN {
    public int round(double n) { ...; }
  };

  public abstract int round(double n);
}

int foo(Rounding roundMethod) {
  return roundMethod.round(someCalculation());
}

int bar() {
  return foo(Rounding.ROUND_UP);
}

请注意，通过RMI / IIOP传输枚举时存在问题。看到这个线程：

http://www.velocityreviews.com/forums/t390342-enum-equality.html

==通常可以，并且==和都有优点.equals()。我个人更喜欢.equals()在比较包括在内enum的对象时始终使用。另请参阅以下讨论：

比较Java枚举成员：==或equals（）？