Est-il acceptable d'utiliser == sur les énumérations en Java?

Puis-je utiliser des ==énumérations en Java ou dois-je utiliser .equals()? Dans mes tests, cela ==fonctionne toujours, mais je ne suis pas sûr que j'en soit garanti. En particulier, il n'y a pas de .clone()méthode sur une enum, donc je ne sais pas s'il est possible d'obtenir une enum pour laquelle .equals()retournerait une valeur différente de ==.

Par exemple, est-ce OK:

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

Ou dois-je l'écrire de cette façon:

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

Juste mes 2 cents: Voici le code pour Enum.java, tel que publié par Sun, et faisant partie du 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;
    }


}

Oui, == est très bien - il n'y a qu'une seule référence pour chaque valeur.

Cependant, il existe une meilleure façon d'écrire votre méthode ronde:

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

Une façon encore meilleure de le faire est de mettre la fonctionnalité dans l'énumération elle-même, afin que vous puissiez simplement appeler roundingMode.round(someValue). Cela touche le cœur des énumérations Java - ce sont des énumérations orientées objet , contrairement aux «valeurs nommées» trouvées ailleurs.

EDIT: La spécification n'est pas très claire, mais la section 8.9 stipule:

Le corps d'un type enum peut contenir des constantes enum. Une constante enum définit une instance du type enum. Un type enum n'a pas d'instances autres que celles définies par ses constantes enum.

Oui, c'est comme si vous aviez créé des instances singleton pour chaque valeur de l'énumération:

classe abstraite publique RoundingMode {
  public static final RoundingMode HALF_UP = new RoundingMode ();
  public static final RoundingMode HALF_EVEN = new RoundingMode ();

  private RoundingMode () {
    // la portée privée empêche tout sous-type en dehors de cette classe
  }
}

Cependant , la enumconception vous offre divers avantages:

• Le toString () de chaque instance imprime le nom donné dans le code.
• (Comme mentionné dans un autre article,) une variable de type enum peut être comparée à des constantes en utilisant la switch-casestructure de contrôle.
• Toutes les valeurs de l'énumération peuvent être interrogées à l'aide du valueschamp «généré» pour chaque type d'énumération
• Voici la grande comparaison des identités: les valeurs d'énumération survivent à la sérialisation sans clonage.

La sérialisation est un gros gotchya. Si je devais utiliser le code ci-dessus au lieu d'une énumération, voici comment l'égalité d'identité se comporterait:

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

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 désérialisé = (RoundingMode) ois.readObject ();

assert (RoundingMode.HALF_UP == désérialisé); // échoue
assert (RoundingMode.HALF_EVEN == désérialisé); // échoue

Vous pouvez résoudre ce problème sans énumération, en utilisant une technique qui implique writeReplaceet readResolve, (voir http://java.sun.com/j2se/1.4.2/docs/api/java/io/Serializable.html ) ...

Je suppose que le point est - Java fait tout son possible pour vous permettre d'utiliser les identités des valeurs enum pour tester l'égalité; c'est une pratique encouragée.

== compare les références de deux objets. Pour les énumérations, il est garanti qu'il n'y aura qu'une seule instance, et par conséquent, pour deux énumérations identiques, == sera vrai.

Référence:

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

(je n'ai rien trouvé dans la documentation Sun)

Voici un code maléfique que vous pourriez trouver intéressant. :RÉ

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

Les énumérations sont un excellent endroit pour brouiller le code polymorphe.

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

Notez qu'il y a un problème lors du transfert d'énumération via RMI / IIOP. Voir ce fil:

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

== est généralement correct, et il y a des avantages à la fois à == et .equals(). Personnellement, je préfère toujours utiliser .equals()lors de la comparaison d'objets, y compris enums. Voir aussi cette discussion:

Comparaison des membres de l'énumération Java: == ou equals ()?