Va bene usare == sulle enumerazioni in Java?

Va bene usare ==su enumerazioni in Java o devo usarlo .equals()? Nei miei test, ==funziona sempre, ma non sono sicuro di averlo garantito. In particolare, non esiste un .clone()metodo su un enum, quindi non so se sia possibile ottenere un enum per il quale .equals()restituirebbe un valore diverso da ==.

Ad esempio, va bene:

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

O devo scriverlo in questo modo:

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

Solo i miei 2 centesimi: ecco il codice per Enum.java, come pubblicato da Sun, e 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ì, == va bene - è garantito che ci sia solo un singolo riferimento per ogni valore.

Tuttavia, c'è un modo migliore per scrivere il tuo metodo rotondo:

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

Un modo ancora migliore per farlo è inserire la funzionalità all'interno dell'enumerazione stessa, quindi puoi semplicemente chiamare roundingMode.round(someValue). Questo arriva al cuore delle enumerazioni Java: sono enumerazioni orientate agli oggetti, a differenza dei "valori denominati" trovati altrove.

EDIT: le specifiche non sono molto chiare, ma la sezione 8.9 afferma:

Il corpo di un tipo enum può contenere costanti enum. Una costante enum definisce un'istanza del tipo enum. Un tipo enum non ha istanze diverse da quelle definite dalle sue costanti enum.

Sì, è come se avessi creato istanze singleton per ogni valore nell'enum:

public abstract class RoundingMode {
  finale statico pubblico RoundingMode HALF_UP = new RoundingMode ();
  finale statico pubblico RoundingMode HALF_EVEN = new RoundingMode ();

  RoundingMode privato () {
    // l'ambito privato impedisce qualsiasi sottotipo al di fuori di questa classe
  }
}

Tuttavia , il enumcostrutto ti offre vari vantaggi:

• Il toString () di ogni istanza stampa il nome dato nel codice.
• (Come accennato in un altro post,) una variabile di tipo enum può essere confrontata con le costanti utilizzando la switch-casestruttura di controllo.
• Tutti i valori nell'enumerazione possono essere interrogati utilizzando il valuescampo "generato" per ogni tipo di enumerazione
• Ecco il grande problema dei confronti di identità: i valori enum sopravvivono alla serializzazione senza clonazione.

La serializzazione è un grande gotchya. Se dovessi usare il codice sopra invece di un enum, ecco come si comporterebbe l'uguaglianza di identità:

RoundingMode original = RoundingMode.HALF_UP;
asserire (RoundingMode.HALF_UP == originale); // passa

ByteArrayOutputStream baos = nuovo ByteArrayOutputStream ();
ObjectOutputStream oos = nuovo ObjectOutputStream (baos);
oos.writeObject (originale);
oos.flush ();

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

asserire (RoundingMode.HALF_UP == deserializzato); // non riesce
asserire (RoundingMode.HALF_EVEN == deserializzato); // non riesce

È possibile risolvere questo problema senza enum, utilizzando una tecnica che coinvolge writeReplacee readResolve, (vedere http://java.sun.com/j2se/1.4.2/docs/api/java/io/Serializable.html ) ...

Immagino che il punto sia: Java fa di tutto per consentirti di utilizzare le identità dei valori enum per testare l'uguaglianza; è una pratica incoraggiata.

== confronta i riferimenti di due oggetti. Per le enumerazioni, è garantito che ci sarà una sola istanza e quindi per due enumerazioni uguali == sarà vero.

Riferimento:

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

(non è stato possibile trovare nulla nei documenti Sun)

Ecco un codice malvagio che potresti trovare interessante. : 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));
}

Gli enum sono un ottimo posto per inceppare il codice polimorfico.

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

Notare che c'è un problema durante il trasferimento di enum tramite RMI / IIOP. Vedi questo thread:

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

== generalmente va bene e ci sono vantaggi sia per == che per .equals(). Personalmente preferisco sempre utilizzare .equals()quando si confrontano gli oggetti, inclusi enumi. Vedi anche questa discussione:

Confronto tra i membri dell'enumerazione Java: == o equals ()?