How to get an Enum Value from a String Value in Java

Java enums are a convenient way to define a set of named constants. However, sometimes we need to convert a string representation of an enum value to its corresponding enum instance. This can be useful in a variety of scenarios, such as parsing user input or reading data from a file.

In this post, we will explore several different approaches to converting a string to an enum value in Java.

Using the valueOf Method

The simplest and most direct way to convert a string to an enum value is to use the valueOf method. This method takes a string argument and returns the corresponding enum constant defined in the enum type.

Here’s an example:

enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {
        String colorString = "RED";
        Color color = Color.valueOf(colorString);
        System.out.println(color);
    }
}

This approach is straightforward and efficient, but it does have one drawback: if the string does not match any of the enum constants, it will throw an IllegalArgumentException.

Using a Loop

Another approach to converting a string to an enum value is to loop over all the enum constants and compare their names to the input string. If a match is found, return the corresponding enum constant.

Here’s an example:

enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static Color fromString(String colorString) {
        for (Color color : Color.values()) {
            if (color.name().equalsIgnoreCase(colorString)) {
                return color;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        String colorString = "red";
        Color color = fromString(colorString);
        System.out.println(color);
    }
}

This approach is a bit slower than the valueOf method, but it is more flexible as it allows you to handle the case where the input string does not match any of the enum constants.

Using a Map

A third approach to converting a string to an enum value is to use a Map to store a mapping from string representations to enum constants. This can be done either by pre-populating the map when the enum type is defined, or by using reflection to dynamically create the mapping at runtime.

Here’s an example using pre-population:

enum Color {
    RED, GREEN, BLUE;

    private static final Map<String, Color> map = new HashMap<>();

    static {
        for (Color color : Color.values()) {
            map.put(color.name(), color);
        }
    }

    public static Color fromString(String colorString) {
        return map.get(colorString.toUpperCase());
    }
}

public class Main {
    public static void main(String[] args) {
        String colorString = "red";
        Color color = Color.fromString(colorString);
        System.out.println(color);
    }
}

This approach is more flexible than the valueOf method and faster than the loop approach, as the Map provides constant-time lookups. However, it does require extra code to define and maintain the mapping.

Using Reflection

Finally, you can use reflection to dynamically retrieve the enum constant from the enum type based on its name. This approach can be useful if you need to convert a string to an enum value for an enum type that is not known at compile time.

Here’s an example:

enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static > T fromString(Class enumType, String value) {
        for (T constant : enumType.getEnumConstants()) {
            if (constant.name().equalsIgnoreCase(value)) {
                return constant;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        String colorString = "red";
        Color color = fromString(Color.class, colorString);
        System.out.println(color);
    }
}