Enum equals() and ==

Question

enum Drill{
        ATTENTION("Attention!"), AT_EASE("At Ease");    
        private String str; 
        private Drill(String str){
            this.str = str;
        }
        public String toString(){
            return str;
        }
    }
public class EnumExample {
    public static void main(String[] args) {
            Drill d1= Drill.valueOf("ATTENTION");
            Drill d2= Drill.valueOf("ATTENTION");
            **System.out.println(d1.equals(d2));//TRUE
            System.out.println(d1==d2);//TRUE**
            System.out.println(Drill.ATTENTION.equals(Drill.valueOf("ATTENTION")));
            System.out.println(Drill.ATTENTION.equals(Drill.AT_EASE));//FALSE 
            System.out.println(Drill.ATTENTION==Drill.valueOf("ATTENTION"));//TRUE
            System.out.println(Drill.ATTENTION==Drill.AT_EASE);//FALSE
}
}

Enum behaviour while using == and equals() seems to be same. According to my knowledge, == just check references. Therefore d1 == d2 should be FALSE. Can anyone explain this behavior why is is TRUE?

Hovercraft Full Of Eels · Answer 1 · 2014-07-02T02:31:42.697

6

== should work fine with enums because there aren't multiple references of a given enum item; there's just one. The Java Language Specification section on enum types, 8.9 states that they are implicitly static and final and so can only be created once.

edited Jul 02 '14 at 02:31

answered Jul 02 '14 at 02:22

Hovercraft Full Of Eels

283,665
25
256
373

Thanks. U mean to say, all references to same enum constant is same? – user3781572 Jul 02 '14 at 02:25
1

@user3781572 they refer to the same object. – djechlin Jul 02 '14 at 02:26
1

@user3781572: they are implicitly final and can only be created once. – Hovercraft Full Of Eels Jul 02 '14 at 02:26

Sotirios Delimanolis · Answer 2 · 2014-07-02T02:36:01.087

You are comparing enum constants. This means that for each enum constant, there is a single instance created.

This

enum Drill{
    ATTENTION("Attention!"), AT_EASE("At Ease"); 
    ...
}

is more or less equivalent to

final class Drill {
    public static final Drill ATTENTION = new Drill("Attention!") {};
    public static final Drill AT_EASE = new Drill("At Ease") {};
    ...
}

The valueOf method

/**
* Returns the enum constant of this type with the specified
* name.
* The string must match exactly an identifier used to declare
* an enum constant in this type.  (Extraneous whitespace 
* characters are not permitted.)
* 
* @return the enum constant with the specified name
* @throws IllegalArgumentException if this enum type has no
* constant with the specified name
*/
public static E valueOf(String name);

returns the value of instance referred to by the variable whose name equals the specified String value.

So

Drill.valueOf("ATTENTION") == Drill.ATTENTION

for every invocation of valueOf with that String value.

You probably need to replace `new ATTENTION` to `new Drill`, etc. — Willem Van Onsem, Jul 02 '14 at 02:31

Elliott Frisch · Answer 3 · 2014-07-02T02:28:29.870

1

Enum Types from the documentation,

An enum type is a special data type that enables for a variable to be a set of predefined constants. The variable must be equal to one of the values that have been predefined for it. Common examples include compass directions (values of NORTH, SOUTH, EAST, and WEST) and the days of the week.

Because they are constants, the names of an enum type's fields are in uppercase letters.

Drill d1= Drill.valueOf("ATTENTION"); // ATTENTION
Drill d2= Drill.valueOf("ATTENTION"); // ATTENTION

So d1 == d2 and d1.equals(d2) because they refer to the same constant value and that is Drill.ATTENTION.

edited Jul 02 '14 at 02:28

answered Jul 02 '14 at 02:24

Elliott Frisch

198,278
20
158
249

2

edited for i.e. v. e.g. It makes a big difference in technical documentation pretty often so thought I should correct. – djechlin Jul 02 '14 at 02:27

score 0 · Answer 4 · answered Jul 02 '14 at 02:25

The JVM is organized so that it is impossible or effectively impossible to instantiate more than one instance of each enum constant. http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

When you call valueOf, it just returns the enum constant that has been already instantiated.

score 0 · Answer 5 · answered Jul 02 '14 at 02:25

In an enum, all items are singletons: they are constructed once (for the sake of simplicity at the beginning of execution, mostly when needed). Thus they follow the Singleton pattern (probably one of the only good reasons to use a singleton).

Thus in memory, there is one instance for every element in the enum.

The valueOf method merely acts as a Flyweight: the JVM keeps some kind of dictionary and returns the appropriate enum item instance.

On a sidenote, I think it is still advisable to use the equals method since this offers the programmer the chance to define equality partitions on the items of the enum. (say A and B are equal, but have some different behavior).

Enum equals() and ==

5 Answers5