Ist es OK == in Enums in Java zu verwenden?

Question

Ist es in Ordnung, == auf Enums in Java zu verwenden, oder muss ich .equals() verwenden? In meinem Test funktioniert == immer, aber ich bin mir nicht sicher, ob ich dafür garantiert bin. Insbesondere gibt es keine .clone() Methode für eine Enumeration, daher weiß ich nicht, ob es möglich ist, eine Enumeration zu erhalten, für die .equals() einen anderen Wert als == zurückgeben würde.

Zum Beispiel ist das in Ordnung:

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

Oder muss ich es auf diese Weise schreiben:

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

Answer 1

nur 2 Cent (alles in der Sun-Dokumentation nicht finden konnte): Hier ist der Code für Enum.java, wie von Sun veröffentlicht, und Teil des 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; 
    } 


} 

Answer 2

Ja, == ist in Ordnung - es ist garantiert nur eine einzige Referenz sein für jeden Wert.

Allerdings gibt es einen besseren Weg, um Ihre Runde Verfahren zum Schreiben:

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

Eine noch besser Art und Weise, es zu tun ist, um die Funktionalität innerhalb des ENUM selbst zu setzen, so dass Sie nur roundingMode.round(someValue) nennen könnte. Das kommt auf das Herz von Java enums - sie sind objektorientierte enums, anders als die "benannten Werte" an anderer Stelle gefunden.

EDIT: Die Spezifikation ist nicht ganz klar, aber section 8.9 heißt es:

Der Körper eines Aufzählungstyp Enum-Konstanten enthalten. Eine Enum-Konstante definiert eine Instanz des Enum-Typs. Ein Enum-Typ hat keine anderen Instanzen als diejenigen, die durch seine enum Konstanten definiert sind.

Answer 3

== vergleicht die Referenzen zweier Objekte. Für Enums ist garantiert, dass es nur eine Instanz gibt und daher für zwei gleiche Enums == wahr ist.

Referenz:

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

meinen

Answer 4

Hier ist etwas bösartiger Code, den Sie vielleicht interessant finden könnten. : 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)); 
} 

Answer 5

Ja, ist es, als ob Sie Singleton-Instanzen für jeden Wert in der Enumeration erstellt hatte:

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

jedoch, das enum Konstrukt gibt Ihnen verschiedene Vorteile:

• Der toString() der Instanz gibt den im Code angegebenen Namen aus.
• (Wie in einem anderen Beitrag erwähnt,) eine Variable des Enum-Typs kann gegen Konstanten mit der switch-case Kontrollstruktur verglichen werden.
• Alle Werte in der Aufzählung können mit dem values Feld abgefragt werden, die ‚‘ erzeugt wird für jeden Aufzählungstyp
• Hier die großen w.r.t Identitätsvergleiche ist: ENUM-Werte Serialisierung ohne Klonen überleben.

Die Serialisierung ist ein großer Gotchya. Wenn ich den Code oben anstelle eines Enum verwenden waren, ist hier, wie Identität Gleichheit verhalten würde:

 
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 

Sie können Adresse dieses Problem ohne Enum, eine Technik, die writeReplace und readResolve beinhaltet (siehe http://java.sun.com/j2se/1.4.2/docs/api/java/io/Serializable.html) ...

Ich denke, der Punkt ist - Java geht aus dem Weg, damit Sie die Identitäten von Enum-Werten zum Testen der Gleichheit verwenden können; Es ist eine ermutigende Praxis.

Answer 6

Enums sind ein großartiger Ort, um polymorphen Code zu blockieren.

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

Answer 7

Beachten Sie, dass beim Übertragen von Enum über RMI/IIOP ein Problem auftritt. Siehe dieses Thema anschauen:

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

Answer 8

== im Allgemeinen in Ordnung ist, und es gibt Vorteile sowohl == und .equals(). Ich persönlich bevorzuge immer .equals() beim Vergleich von Objekten, einschließlich enum s. Siehe auch diese Diskussion:

Comparing Java enum members: == or equals()?