¿Está bien usar == en enumeraciones en Java?

¿Está bien usar ==en enumeraciones en Java, o necesito usarlo .equals()? En mis pruebas, ==siempre funciona, pero no estoy seguro si tengo la garantía de eso. En particular, no hay un .clone()método en una enumeración, por lo que no sé si es posible obtener una enumeración para la que .equals()devolvería un valor diferente a ==.

Por ejemplo, esto está bien:

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

O necesito escribirlo de esta manera:

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

Solo mis 2 centavos: aquí está el código de Enum.java, publicado por Sun, y parte del 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;
    }


}

Sí, == está bien, se garantiza que habrá una única referencia para cada valor.

Sin embargo, hay una mejor manera de escribir su método de ronda:

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

Una forma aún mejor de hacerlo es poner la funcionalidad dentro de la enumeración, por lo que podría simplemente llamar roundingMode.round(someValue). Esto llega al corazón de las enumeraciones de Java: son enumeraciones orientadas a objetos, a diferencia de los "valores con nombre" que se encuentran en otros lugares.

EDITAR: La especificación no es muy clara, pero la sección 8.9 establece:

El cuerpo de un tipo enum puede contener constantes enum. Una constante enum define una instancia del tipo enum. Un tipo enum no tiene más instancias que las definidas por sus constantes enum.

Sí, es como si hubiera creado instancias singleton para cada valor en la enumeración:

RoundingMode de clase abstracta pública {
  RoundingMode final estático público HALF_UP = new RoundingMode ();
  RoundingMode final estático público HALF_EVEN = new RoundingMode ();

  Private RoundingMode () {
    // el ámbito privado evita cualquier subtipo fuera de esta clase
  }
}

Sin embargo , la enumconstrucción le brinda varios beneficios:

• El toString () de cada instancia imprime el nombre dado en el código.
• (Como se mencionó en otra publicación,) una variable del tipo enum se puede comparar con constantes usando la switch-caseestructura de control.
• Todos los valores de la enumeración se pueden consultar utilizando el valuescampo que se 'genera' para cada tipo de enumeración
• Aquí está la más importante de las comparaciones de identidad: los valores de enumeración sobreviven a la serialización sin clonación.

La serialización es una gran gotchya. Si tuviera que usar el código anterior en lugar de una enumeración, así es como se comportaría la igualdad de identidad:

RoundingMode original = RoundingMode.HALF_UP;
afirmar (RoundingMode.HALF_UP == original); // pasa

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

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

afirmar (RoundingMode.HALF_UP == deserializado); // falla
afirmar (RoundingMode.HALF_EVEN == deserializado); // falla

Usted puede abordar esta cuestión sin enumeración, utilizando una técnica que implica writeReplacey readResolve, (ver http://java.sun.com/j2se/1.4.2/docs/api/java/io/Serializable.html ) ...

Supongo que el punto es que Java hace todo lo posible para permitirle usar las identidades de los valores de enumeración para probar la igualdad; es una práctica recomendada.

== compara las referencias de dos objetos. Para las enumeraciones, se garantiza que solo habrá una instancia y, por lo tanto, para dos enumeraciones que sean iguales, == será verdadero.

Referencia:

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

(no pude encontrar nada en los documentos de Sun)

Aquí hay un código maligno que puede resultarle interesante. :RE

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

Las enumeraciones son un gran lugar para bloquear código polimórfico.

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

Tenga en cuenta que hay un problema al transferir la enumeración a través de RMI / IIOP. Ver este hilo:

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

== generalmente está bien, y hay ventajas tanto para == como para .equals(). Personalmente prefiero usar siempre .equals()al comparar objetos, incluidos enums. Vea también esta discusión:

Comparando miembros de enumeración de Java: == o igual ()?