Compare string with toString() representation of enum value using switch in Java

Question

I have a long list of enumerations that are being referenced and selected via if-statements in my code, however, I want to use switch statements as I have a huge number of such statements in multiple places. This is a small subset of the enumerations that I have:

public enum MYENUM {
    FOO1("hello"),
    FOO2("goodbye"),
 
    private final String toString;

    MYENUM(String toString) {
        this.toString = toString;
    }

    @Override
    public String toString() {
        return this.toString;
    }
}

Previously I had:

String toCheck = "hello;"

if (toCheck.equals(MYENUM.FOO1.toString())) {
    //Do stuff
}

if (toCheck.equals(MYENUM.FOO2.toString())) {
    //Do stuff
}

But now I want:

String toCheck = "hello;"
switch(toCheck) {
    case MYENUM.FOO1.toString():
        //Do stuff
        break;

    case MYENUM.FOO2.toString():
        //Do stuff
        break;

}

Needless to say, this does not work, I can't even enter the toString() function of the Enum in the case, 'toString' has private access in 'MYENUM'. How can I modify my switch statement so that I can properly switch on the Strings?

Answer 1

You can't. The strings in a switch block have to be constants, and while MYENUM.FOO1.toString() feels constant, the JVM has no idea that it is (after all, your toString() method could roll some dice, ping a web server, who knows what it'll do). Hence, the JVM will not allow it and nothing you're going to do can make it work.

Instead, make a map that maps these string values to the right enum. This also gives you the performance benefit you might be looking for (O[1] lookup instead of O[n] lookup). Not that this will matter unless you have hundreds, maybe even thousands of enums. The enum itself can do this:

public enum MYENUM {
    FOO1("hello"),
    FOO2("goodbye"),
 
    private final String toString;

    MYENUM(String toString) {
        this.toString = toString;
    }

    @Override
    public String toString() {
        return this.toString;
    }

    private static final Map<String, MYENUM> stringToValue;
    static {
      var m = new HashMap<String, MYENUM>();
      for (MYENUM e : values()) m.put(e.toString(), e);
      stringToValue = Collections.unmodifiableMap(m);
    }

    public static MYENUM of(String v) {
      return stringToValue.get(v);
    }
}

Now replace your entire switch block with simply MYENUM.of(toCheck).

Answer 2

In short, switch on an enum, not a String.

Here's how I construct and use enums like yours (i.e. using an alternate value):

public enum MyEnum {
    FOO1("hello"),
    FOO2("goodbye"),

    private static final Map<String, MyEnum> lookupMap = new TreeMap<>();
 
    private final String displayStr;

    MyEnum(String displayStr) {
        this.displayStr= displayStr;
    }

    public static MyEnum parse(String s)
    {
      if (s == null) throw new NullPointerException("Cannot parse null String");

      if (lookupMap.isEmpty())
      {
        for (MyEnum myEnum: values())
        {
           lookupMap.put(myEnum.name(), myEnum);
           lookupMap.put(myEnum.displayStr, myEnum);
        }
      }

      MyEnum result = lookupMap.get(s);
      if (result == null) throw new IllegalArgumentException("No MyEnum corresponds to " + s);
      return result;
    }

    @Override
    public String toString() {
        return displayStr;
    }
}

Your switch statement then becomes:

MyEnum toCheck = MyEnum.parse("hello");
if (toCheck == null)
{
  // In this block you must either return, throw an exception,
  // or set toCheck to a non-null default value.
}

switch(toCheck) {
    case MYENUM.FOO1:
        //Do stuff
        break;

    case MYENUM.FOO2:
        //Do stuff
        break;

// etc.
}

Answer 3

Unfortunately, you cannot directly use a switch statement with method calls in the case labels like MYENUM.FOO1.toString(). The case expressions in a switch statement must be compile-time constant expressions. The result of a method call like toString() is not known until runtime so it's not a constant expression. This is why you cannot directly switch on the result of toString().

However, you can create a static method that performs the logic of the switch statement using a Map.

import java.util.*;
import java.util.stream.*;

public enum MYENUM {
    FOO1("hello"),
    FOO2("goodbye");

    private final String toString;

    MYENUM(String toString) {
        this.toString = toString;
    }

    @Override
    public String toString() {
        return this.toString;
    }

    private static final Map<String, MYENUM> ENUM_MAP = Arrays.stream(MYENUM.values())
            .collect(Collectors.toUnmodifiableMap(MYENUM::toString, e -> e));

    public static MYENUM get(String name) {
        return ENUM_MAP.get(name);
    }
}

You would use the get() method in your switch statement like this:

String toCheck = "hello";

switch (MYENUM.get(toCheck)) {
    case FOO1 -> {
        // Do stuff
    }
    case FOO2 -> {
        // Do stuff
    }
    default -> {
        // Handle case where no match is found
    }
}

Answer 4

Instead of using the switch, you can utilize the Enum#values method and loop on each entry.

Enum#valueOf (Java SE 20 & JDK 20),

"... All the constants of an enum class can be obtained by calling the implicit public static T[] values() method of that class ..."

So, here is an example enum.

enum Value {
    A("ABC"), B("DEF"), C("GHI");

    public String string;

    Value(String string) {
        this.string = string;
    }
}

And, here is an example usage.

String string = "GHI";
Value value = null;
for (Value valueB : Value.values()) {
    if (valueB.string.equals(string)) {
        value = valueB;
        break;
    }
}
System.out.println("value = " + value);

Output

value = C

Additionally, you could just add this as a static method within the enum.

enum Value {
    A("ABC"), B("DEF"), C("GHI");

    public String string;

    Value(String string) {
        this.string = string;
    }

    /** @return null if not found */
    static Value parse(String string) {
        for (Value value : Value.values()) {
            if (value.string.equals(string)) return value;
        }
        return null;
    }
}

If you did want to utilize the switch structure, here is an example, where string is the toCheck value.

Value value = Value.parse(string);
if (value != null) {
    switch (value) {
        case A -> {
            //Do stuff
        }
        case B -> {
            //Do stuff
        }
        case C -> {

        }
    }
}