Is there a particular or major reason why I should choose 'enum' over array for a short fixed list in Java?

Question

I am aware there are similar questions, and I have read the answers, but maybe I'm just not quite grasping the full difference of its use, even though I understand their difference when for example, initializing a String. Example:

String[] favorite = {"dog", "cat", "alien"};

vs

enum favorite = {dog, cat, alien}

Or maybe the use of either in the above case is similar, but their difference can be grasped better in another example? Is it that enum can clearly store more properties for a variable when creating the class?

Answer 1

The big advantage of enum is that the compiler checks for typos (type safety). For instance, if you assign the value "dag" to a string, the compiler does not complain. But, you cannot assign the value favorite.dag to a variable (of type favorit). Also, enum makes the code more readable and it is faster (comparison, for instance).

Answer 2

Just like @AhmadWabbi said, it's mostly type safety.

With enums you also have the ability to write methods corresponding to the enum. For instance:

public enum Favorite = {
    dog("woof"), 
    cat("meow"),
    alien("zoink")

    private String sound;

    Favorite(String sound) {
        this.sound = sound;
    }

    public String makeSound() {
        return sound;
    }
}

Which then let you call the method on a known enum (Favorite.dog.makeSound()) or if the enum is a parameter to another method.

Answer 3

The biggest advantage is that an enum is type-safe. An enum value can only take on one of the defined values (or null). (Note that an enum in Java is not like an enum in C++ or C#, where it is more like an alias for an int).

If you use a type like String or int, you can assign to that any value that fits in a String or int, even if it's not one of the limited set of values that you want it to contain.

It also makes programs easier to read, because when for example a method takes an enum type as a parameter, you immediately know what it means, and what values are valid - if it would, for example, take a String, you don't automatically know which strings are valid inputs and which are not.

Answer 4

There is no need to be too sophisticated with a program. If you have three strings use the string array. If you have three distinct entities which differ by something else in addition to their names, use enum (on which you, evidently, will then be operating somehow).

Answer 5

Enums are easy to add new functionality to your code. Strings have their limits, you can decide yourself if you need all the benefits of enums or string will do for the job.

For example:

  public enum favourite {
    dog, cat, cow;

    public boolean barking(){
      switch(this){
        case dog:
          return true;
        case cat:
        case cow:  
          return false;
      }
      throw new AssertionError();
    }

  }

Answer 6

Enum sort of create a namespace . Thus two constants with same name can belong to different enums. Of course , you can emulate it with ArrayList but its not intuitive , because its supposed to acts as a container rather than a logical namespace holding constants.

You can compare it old style enums from C++ , where two enum declarations holding a same named constant shows a error . With new style class enums in c++ adds sort of namespace to it , which was not possible earlier.

And yes Enums in Java already have a name-spacing feature. By the way , Enum and ArrayList both have different purpose.

Answer 7

The biggest advantage of enums is that they are type-safe: a variable of an enum type can only hold values defined in that enum. By the way, in some circumstances this can be a big disadvantage, a show-stopper even: if the possible values are not known at compile time (for example, because you need to fetch them from a database at run-time) you cannot use enums.

Although I do not see a clear advantage of it (and if I don't see a clear advantage I would always use the established coding practice, which is using an enum), you can certainly use strings as a kind of enums. Performance will probably be a bit worse because of the string comparisons, but in most cases unnoticeably so.

However, I would strictly advice against your array example, for the following reasons:

• Arrays are mutable. If your project is large enough, someone will eventually write favorites[0] = "beer"; and thus cause mysterious bugs in unrelated parts of the code.
• Using an array has no advantage in readability. The meaning String myFavorite = favorites[1]; is completely opaque, whereas String myFavorite = "cat"; or Favorite myFavorite = Favorite.CAT; are immediately clear.
• String literals can be used in switch statements, but not expressions like favorites[2]. So switch (myFavorite) { case favorites[2]: ... } is not legal Java (whereas switch (myFavorite) { case "alien": ... } is).

If you really want to use Strings as enums, then define String constants:

public static final String FAV_DOG = "dog";
public static final String FAV_CAT = "cat";
public static final String FAV_ALIEN = "alien";