Можно ли использовать == для перечислений в Java?

Просто мои 2 цента: вот код для Enum.java, опубликованный Sun, и часть 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;
    }


}

Да, == это нормально - для каждого значения гарантированно будет только одна ссылка.

Однако есть лучший способ написать метод round:

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 сообщает:

Тело типа перечисления может содержать константы перечисления. Константа перечисления определяет экземпляр типа перечисления. Тип перечисления не имеет экземпляров, кроме тех, которые определены его константами перечисления.

Да, это как если бы вы создали одноэлементные экземпляры для каждого значения в перечислении:

public abstract class RoundingMode {
  public static final RoundingMode HALF_UP = new RoundingMode();
  public static final RoundingMode HALF_EVEN = new RoundingMode();

  private RoundingMode() {
    // private scope prevents any subtypes outside of this class
  }
}

Однако конструкция enum дает ряд преимуществ:

• Функция toString() каждого экземпляра печатает имя, указанное в коде.
• (Как упоминалось в другом посте) переменную типа enum можно сравнить с константами, используя управляющую структуру switch-case.
• Все значения в перечислении можно запросить с помощью поля values, которое «сгенерировано» для каждого типа перечисления.
• Вот что важно для сравнения идентификаторов: значения перечисления сохраняются при сериализации без клонирования.

Сериализация - большая проблема. Если бы я использовал приведенный выше код вместо перечисления, вот как повело бы себя равенство идентичности:

RoundingMode original = RoundingMode.HALF_UP;
assert (RoundingMode.HALF_UP == original); // passes

ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(original);
oos.flush();

ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
RoundingMode deserialized = (RoundingMode) ois.readObject();

assert (RoundingMode.HALF_UP == deserialized); // fails
assert (RoundingMode.HALF_EVEN == deserialized); // fails

Вы можете решить эту проблему без перечисления, используя технику, включающую writeReplace и readResolve (см. http://java.sun.com/j2se/1.4.2/docs/api/java/io/Serializable.html)...

Я думаю, дело в том, что Java делает все возможное, чтобы вы могли использовать идентификаторы значений перечисления для проверки равенства; это рекомендуемая практика.

== сравнивает ссылки двух объектов. Для перечислений гарантируется, что будет только один экземпляр, поэтому для любых двух одинаковых перечислений == будет истинным.

Ссылка:

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

Обратите внимание, что при передаче enum через RMI/IIOP возникают проблемы. Смотрите эту тему:

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

== в целом нормально, и есть преимущества как у ==, так и у .equals(). Лично я предпочитаю всегда использовать .equals() при сравнении объектов, включая enum. Смотрите также это обсуждение:

Сравнение элементов перечисления Java: == или equals()?