How to get an enum value from a string value in Java

Learn how to get an enum value from a string value in java with practical examples, diagrams, and best practices. Covers java, enums, guava development techniques with visual explanations.
Tags:
Categories:

How to Get an Enum Value from a String in Java

How to Get an Enum Value from a String in Java

Learn various techniques to convert a string representation into its corresponding enum constant in Java, covering built-in methods and external libraries like Guava.

Enums in Java provide a powerful way to define a collection of constants. Often, you'll encounter scenarios where you receive a string value (e.g., from user input, a configuration file, or an API response) and need to convert it into its corresponding enum constant. This article explores different approaches to achieve this, discussing their advantages, disadvantages, and best use cases.

Using valueOf() Method

Every enum in Java automatically inherits a static valueOf(String name) method. This method takes a string argument and returns the enum constant with the specified name. If the string does not match any enum constant's name, it throws an IllegalArgumentException.

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class EnumConverter {
    public static void main(String[] args) {
        String dayString = "MONDAY";
        try {
            Day day = Day.valueOf(dayString);
            System.out.println("Converted day: " + day);

            String invalidDayString = "FUNDAY";
            Day invalidDay = Day.valueOf(invalidDayString);
            System.out.println("Converted invalid day: " + invalidDay);
        } catch (IllegalArgumentException e) {
            System.err.println("Error: Invalid enum string provided: " + e.getMessage());
        }
    }
}

Demonstrates valueOf() method for enum conversion, including error handling.

Handling Case-Insensitive Conversion

Since valueOf() is case-sensitive, you might need a more robust solution if your input strings can vary in case (e.g., "monday", "Monday", "MONDAY"). One common approach is to convert the input string to uppercase before passing it to valueOf().

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class CaseInsensitiveConverter {
    public static Day fromString(String dayString) {
        try {
            return Day.valueOf(dayString.toUpperCase());
        } catch (IllegalArgumentException e) {
            return null; // Or throw a custom exception
        }
    }

    public static void main(String[] args) {
        System.out.println("Converted 'monday': " + fromString("monday"));
        System.out.println("Converted 'MONDAY': " + fromString("MONDAY"));
        System.out.println("Converted 'Monday': " + fromString("Monday"));
        System.out.println("Converted 'InvalidDay': " + fromString("InvalidDay"));
    }
}

Shows how to handle case-insensitive enum conversion.

A flowchart diagram illustrating the case-insensitive enum conversion process. Start node leads to 'Input String'. This leads to 'Convert to Uppercase'. Then to 'Call Enum.valueOf()'. A decision node 'Is enum constant found?' branches to 'Return Enum Constant' (if yes) or 'Handle Error / Return Null' (if no). Use rounded rectangles for start/end, rectangles for processes, and a diamond for decision.

Flowchart for Case-Insensitive Enum Conversion

Using a Custom Lookup Method

For more complex scenarios, such as when the string representation doesn't directly match the enum constant name, or when you need to map multiple string aliases to a single enum constant, a custom lookup method within the enum itself is ideal. This often involves storing the string mapping as a field in the enum.

import java.util.HashMap;
import java.util.Map;

public enum Status {
    ACTIVE("active", "ACT"),
    INACTIVE("inactive", "INA"),
    PENDING("pending", "PEN");

    private final String primaryName;
    private final String shortCode;

    Status(String primaryName, String shortCode) {
        this.primaryName = primaryName;
        this.shortCode = shortCode;
    }

    // Static map for efficient lookup
    private static final Map<String, Status> LOOKUP_MAP = new HashMap<>();

    static {
        for (Status status : Status.values()) {
            LOOKUP_MAP.put(status.primaryName.toLowerCase(), status);
            LOOKUP_MAP.put(status.shortCode.toLowerCase(), status);
        }
    }

    public static Status fromString(String text) {
        return LOOKUP_MAP.get(text.toLowerCase());
    }

    public static void main(String[] args) {
        System.out.println("Converted 'active': " + Status.fromString("active"));
        System.out.println("Converted 'ACT': " + Status.fromString("ACT"));
        System.out.println("Converted 'pending': " + Status.fromString("pending"));
        System.out.println("Converted 'unknown': " + Status.fromString("unknown"));
    }
}

Example of a custom lookup method with multiple string mappings.

Using Guava's Enums.getIfPresent()

Guava, a popular Google library for Java, provides a convenient utility called Enums.getIfPresent(). This method attempts to convert a string to an enum constant and returns an Optional containing the enum if successful, or Optional.absent() (Guava's Optional equivalent) if not found. This eliminates the need for explicit try-catch blocks for IllegalArgumentException.

import com.google.common.base.Enums;
import com.google.common.base.Optional;

public enum Color {
    RED, GREEN, BLUE
}

public class GuavaConverter {
    public static void main(String[] args) {
        String colorString = "RED";
        Optional<Color> colorOptional = Enums.getIfPresent(Color.class, colorString);

        if (colorOptional.isPresent()) {
            System.out.println("Converted color: " + colorOptional.get());
        } else {
            System.out.println("Color not found for: " + colorString);
        }

        String invalidColorString = "YELLOW";
        Optional<Color> invalidColorOptional = Enums.getIfPresent(Color.class, invalidColorString);

        if (invalidColorOptional.isPresent()) {
            System.out.println("Converted color: " + invalidColorOptional.get());
        } else {
            System.out.println("Color not found for: " + invalidColorString);
        }
    }
}

Demonstrates enum conversion using Guava's Enums.getIfPresent().

Choosing the Right Method

The best method depends on your specific requirements:

  • Enum.valueOf(): Simplest for direct, case-sensitive matches where an IllegalArgumentException is acceptable for invalid inputs.
  • Case-insensitive valueOf() with toUpperCase(): Ideal when input case might vary but still matches enum constant names.
  • Custom Lookup Method: Most flexible for complex mappings, aliases, or when performance is critical for frequent lookups and you need to avoid exceptions.
  • Guava's Enums.getIfPresent(): A good choice for clean, optional-based handling of potentially invalid inputs, reducing boilerplate try-catch.

By understanding these different approaches, you can confidently handle string-to-enum conversions in your Java applications, choosing the method that best fits your project's needs for robustness, flexibility, and readability.