How to Convert a String to an Enum in Java

Q: How do I get an enum value from a string in Java?

Call the enum's generated valueOf method: Size.valueOf("MEDIUM") returns Size.MEDIUM. The string must match the constant's name exactly, including case, or it throws IllegalArgumentException: No enum constant Main.Size.medium. A null string throws NullPointerException: Name is null. For input you don't control, wrap the lookup in a helper that returns Optional .

Q: Should I compare Java enums with == or equals()?

Use ==. There is only ever one instance of each constant, so both give the same result, but == is null-safe (null == Size.LARGE is false, while missing.equals(Size.LARGE) throws NullPointerException) and it is checked at compile time: Size.LARGE == Color.RED fails with incomparable types, where equals compiles and returns false.

Q: How do I loop over all values of an enum?

Use a for-each loop over Size.values(), which returns the constants in declaration order. EnumSet.allOf(Size.class) gives the same constants as a Set, and EnumSet.range(Size.MEDIUM, Size.EXTRA_LARGE) a slice of them. To get the names as a list, Arrays.stream(Size.values()).map(Enum::name).toList() prints [SMALL, MEDIUM, LARGE, EXTRA_LARGE] (toList() needs Java 16+).

Q: How do I make Enum.valueOf case-insensitive?

There is no built-in option. Either loop over values() and return the constant whose name().equalsIgnoreCase(input), or call valueOf(input.strip().toUpperCase(Locale.ROOT)) inside a try/catch. Always pass Locale.ROOT: with a Turkish default locale, "medium".toUpperCase() is MEDİUM, which matches no constant.

Q: What is the difference between name() and toString() on an enum?

name() returns the identifier exactly as declared and is final, so it always works with valueOf. toString() returns the same string by default, but an enum can override it to return a display label. After overriding it to "Large", Size.valueOf(Size.LARGE.toString()) throws No enum constant Main.Size.Large. Persist and transmit name() (or your own code field) and use toString() for display.

Q: How do I convert an int to an enum in Java?

If the int is the ordinal, index into the array: Size.values()[2] is LARGE, and an index past the end throws ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4. Ordinals shift when someone reorders or inserts constants, so don't store them. For stable numbers such as HTTP status codes, give the enum an int field and look it up in a static map, as in section 3.

Quick answer

Call the enum's built-in valueOf: Size.valueOf("MEDIUM") returns Size.MEDIUM. It needs the exact, case-sensitive constant name and throws IllegalArgumentException for anything else (and NullPointerException for null), so wrap user input in a lookup that returns an Optional. Compare the result with ==.

Every Java enum gets two static methods from the compiler: valueOf(String), which turns a constant's name into the constant, and values(), which returns all of them. They don't appear in the Javadoc for java.lang.Enum, which is why so many people go looking for them. valueOf is strict on purpose, so real code usually adds a forgiving lookup on top: case-insensitive, by a custom code, or returning Optional instead of throwing. The examples below use one small Size enum throughout. Each one runs on this page: hit Run, then edit the code and run it again.

1valueOf(): the exact constant nameRecommended

Size.valueOf(name) returns the constant whose name is exactly name: same case, no surrounding spaces. The generic form, Enum.valueOf(Size.class, name), does the same lookup when your code receives the enum type as a Class object. Both throw on a miss rather than returning null, which is right when a bad name means a bug, such as a typo in a config key you control.

Main.java

public class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE }

    public static void main(String[] args) {
        Size size = Size.valueOf("MEDIUM");
        System.out.println(size);
        System.out.println(size == Size.MEDIUM);

        // The generic form does the same lookup for any enum class
        Size large = Enum.valueOf(Size.class, "LARGE");
        System.out.println(large);

        // valueOf wants the exact constant name: case, spaces and all
        for (String input : new String[] { "medium", " MEDIUM", "XL" }) {
            try {
                Size.valueOf(input);
            } catch (IllegalArgumentException e) {
                System.out.println("IllegalArgumentException: " + e.getMessage());
            }
        }

        // null is a different exception
        try {
            Size.valueOf(null);
        } catch (NullPointerException e) {
            System.out.println("NullPointerException: " + e.getMessage());
        }
    }
}

Output

Prints MEDIUM, true and LARGE. Then each bad input throws its own IllegalArgumentException: No enum constant Main.Size.medium, No enum constant Main.Size. MEDIUM (the leading space is part of the name it tried) and No enum constant Main.Size.XL. The message uses the enum's full name, Main.Size, because it is nested in Main. A null name is different: NullPointerException: Name is null. Catch both if the string can come from outside your program.

2Case-insensitive lookup that returns Optional

For input from users, URLs or files, you want "medium" and " Large " to work and a bad value to be an ordinary result, not an exception. Java has no built-in case-insensitive valueOf, so write a short helper that returns Optional. Loop over values() and compare with equalsIgnoreCase, or, for a helper that works with any enum, upper-case the input with Locale.ROOT and catch the exception. If you already use Guava or Apache Commons Lang, Enums.getIfPresent and EnumUtils.getEnumIgnoreCase do the same job.

Main.java

import java.util.Locale;
import java.util.Optional;

public class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE }

    // Case-insensitive, trims spaces, never throws
    static Optional<Size> parseSize(String text) {
        if (text == null) {
            return Optional.empty();
        }
        String key = text.strip();
        for (Size size : Size.values()) {
            if (size.name().equalsIgnoreCase(key)) {
                return Optional.of(size);
            }
        }
        return Optional.empty();
    }

    // The same idea for any enum type, built on Enum.valueOf
    static <E extends Enum<E>> Optional<E> parseEnum(Class<E> type, String text) {
        if (text == null) {
            return Optional.empty();
        }
        try {
            return Optional.of(Enum.valueOf(type, text.strip().toUpperCase(Locale.ROOT)));
        } catch (IllegalArgumentException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        String[] inputs = { "medium", " Large ", "extra_large", "XL", "", null };
        for (String input : inputs) {
            String shown = input == null ? "null" : "\"" + input + "\"";
            System.out.printf("%-14s %s%n", shown, parseSize(input));
        }

        // Pick a default, or fail with your own message
        Size size = parseSize("XL").orElse(Size.MEDIUM);
        System.out.println(size);
        System.out.println(parseEnum(Size.class, "small").orElseThrow());

        // Why Locale.ROOT: with a Turkish default locale, toUpperCase()
        // turns "i" into a dotted capital I, and the lookup fails
        Locale.setDefault(Locale.forLanguageTag("tr"));
        String upper = "medium".toUpperCase();
        System.out.println(upper + " " + parseSize(upper).isPresent());
        try {
            Size.valueOf(upper);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        System.out.println(parseEnum(Size.class, "medium"));
    }
}

Output

The first six lines show the helper: "medium", " Large " and "extra_large" give Optional[MEDIUM], Optional[LARGE] and Optional[EXTRA_LARGE], while "XL" (a code, not a name: see the next section), the blank string and null all give Optional.empty. The caller then decides what a miss means: orElse(Size.MEDIUM) prints MEDIUM and orElseThrow() prints SMALL. The last three lines show why the generic helper passes Locale.ROOT. With a Turkish default locale, a bare toUpperCase() turns "medium" into MEDİUM with a dotted capital I, so valueOf throws No enum constant Main.Size.MEDİUM, while parseEnum still returns Optional[MEDIUM]. equalsIgnoreCase uses no locale at all, so parseSize prints true for the same string. strip() needs Java 11+ (use trim() on Java 8) and the no-argument orElseThrow() needs Java 10+.

3Look up by a code or label with a static map

Often the string you receive isn't the constant's name at all but some external value: a size code like "XL", an HTTP status, a database value. Store that value in a field, then build a static final map from it to the constant once, when the enum class loads. Each lookup is then a single get instead of a loop. The map has to be built in a static initializer that runs after the constants exist, which is what declaring it with Arrays.stream(values()) does.

Main.java

import java.util.Arrays;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {
    enum Size {
        SMALL("S", "Small"),
        MEDIUM("M", "Medium"),
        LARGE("L", "Large"),
        EXTRA_LARGE("XL", "Extra large");

        private final String code;
        private final String label;

        Size(String code, String label) {
            this.code = code;
            this.label = label;
        }

        // Built once, when the enum class is initialized
        private static final Map<String, Size> BY_CODE = Arrays.stream(values())
                .collect(Collectors.toUnmodifiableMap(size -> size.code, Function.identity()));

        static Optional<Size> fromCode(String code) {
            return Optional.ofNullable(code == null ? null : BY_CODE.get(code));
        }

        String code() {
            return code;
        }

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

    public static void main(String[] args) {
        System.out.println(Size.fromCode("XL"));
        System.out.println(Size.fromCode("M").map(Size::name).orElse("?"));
        System.out.println(Size.fromCode("XXL"));
        System.out.println(Size.fromCode(null));

        // Round trip: constant -> code -> constant
        Size size = Size.LARGE;
        System.out.println(size.code() + " " + (Size.fromCode(size.code()).orElseThrow() == size));
    }
}

Output

Prints Optional[Extra large]: an Optional prints its value with toString(), which this enum overrides to return the label. Mapping to Size::name gives MEDIUM, an unknown code and null both give Optional.empty, and the round trip prints L true. The tempting shortcut, calling BY_CODE.put(code, this) in the constructor, doesn't compile: illegal reference to static field from initializer, because the constants are created before any other static field is set. The null check matters too, since the map from Collectors.toUnmodifiableMap (Java 10+) throws NullPointerException on get(null). A useful side effect: two constants with the same code fail at startup with IllegalStateException: Duplicate key S (attempted merging values SMALL and MINI).

4Which lookup should you use?

Method	Matches	On no match	Best for
Size.valueOf(s)	Exact name only	Throws IllegalArgumentException	Names you wrote yourself: config keys, saved values
Enum.valueOf(Size.class, s)	Exact name only	Throws IllegalArgumentException	Generic code that receives the enum class
values() + equalsIgnoreCase	Name, any case	Optional.empty()	User input for one enum
valueOf(s.toUpperCase(Locale.ROOT)) in try/catch	Name, any case	Optional.empty()	One helper shared by every enum
static Map<String, Size>	Your own code or label	Optional.empty()	External values like "XL" or 404
Size.values()[i]	Position (ordinal)	Throws ArrayIndexOutOfBoundsException	Rarely: ordinals change when constants are reordered

5Loop over every constant: values(), name() and toString()

Size.values() returns every constant in declaration order, so a for-each loop over it is how you iterate an enum. Each constant has three ways to describe itself: ordinal() is its position, name() is the identifier exactly as declared, and toString() returns the name too unless you override it. That difference matters here, because valueOf only ever reads name().

Main.java

import java.util.Arrays;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Map;

public class Main {
    enum Size {
        SMALL("Small"), MEDIUM("Medium"), LARGE("Large"), EXTRA_LARGE("Extra large");

        private final String label;

        Size(String label) {
            this.label = label;
        }

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

    public static void main(String[] args) {
        // values() returns every constant in declaration order
        for (Size size : Size.values()) {
            System.out.printf("%d %-12s %s%n", size.ordinal(), size.name(), size);
        }

        // valueOf reads name(), never toString()
        System.out.println(Size.valueOf(Size.LARGE.name()));
        try {
            Size.valueOf(Size.LARGE.toString());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }

        System.out.println(Arrays.toString(Size.values()));
        System.out.println(Size.values().length);

        // Each call builds a new array, so cache it if you call it in a hot loop
        System.out.println(Size.values() == Size.values());

        // A range of constants, and a map keyed by enum (both keep declaration order)
        System.out.println(EnumSet.range(Size.MEDIUM, Size.EXTRA_LARGE));

        Map<Size, Integer> stock = new EnumMap<>(Size.class);
        stock.put(Size.LARGE, 4);
        stock.put(Size.SMALL, 12);
        stock.put(Size.EXTRA_LARGE, 0);
        System.out.println(stock);
    }
}

Output

The loop prints one row per constant, from 0 SMALL Small to 3 EXTRA_LARGE Extra large. valueOf(Size.LARGE.name()) round-trips to Large, but valueOf(Size.LARGE.toString()) throws No enum constant Main.Size.Large: store and send name(), which is final and can't be overridden, and keep toString() for display. Arrays.toString uses toString(), so it prints [Small, Medium, Large, Extra large], and length is 4. values() == values() is false because each call returns a fresh copy of the array. EnumSet.range gives [Medium, Large, Extra large], and the EnumMap prints {Small=12, Large=4, Extra large=0}: declaration order, not the order the entries were added.

6Compare with == and switch on an enum

Each enum constant is a single object for the life of the program, so == and equals() give the same answer, and Enum.equals is itself implemented as ==. Prefer ==: it can't throw when the left side is null, and the compiler rejects comparisons between two different enum types. Strings are the opposite case, where == is the wrong test (see compare strings in Java).

To branch on a constant, use switch. The arrow-form switch expression (Java 14+) returns a value and needs no default when every constant is listed, and Java 21+ adds case null.

Main.java

import java.util.Locale;

public class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE }

    // Switch expression (Java 14+): no default needed when every constant is covered
    static int price(Size size) {
        return switch (size) {
            case SMALL, MEDIUM -> 18;
            case LARGE -> 20;
            case EXTRA_LARGE -> 22;
        };
    }

    // Java 21+: case null handles null inside the switch instead of throwing
    static String describe(Size size) {
        return switch (size) {
            case null -> "no size chosen";
            case EXTRA_LARGE -> "XL, ships separately";
            default -> size.name().toLowerCase(Locale.ROOT);
        };
    }

    public static void main(String[] args) {
        Size chosen = Size.valueOf("LARGE");
        System.out.println(chosen == Size.LARGE);
        System.out.println(chosen.equals(Size.LARGE));

        // == is null-safe; calling equals on null is not
        Size missing = null;
        System.out.println(missing == Size.LARGE);
        System.out.println(Size.LARGE.equals(missing));
        try {
            System.out.println(missing.equals(Size.LARGE));
        } catch (NullPointerException e) {
            System.out.println("missing.equals(...) threw NullPointerException");
        }

        for (Size size : Size.values()) {
            System.out.println(size + " costs " + price(size));
        }

        System.out.println(describe(Size.SMALL));
        System.out.println(describe(Size.EXTRA_LARGE));
        System.out.println(describe(null));

        // Without case null, a switch on null throws
        try {
            price(missing);
        } catch (NullPointerException e) {
            System.out.println("price(null) threw NullPointerException");
        }
    }
}

Output

Prints true twice, then false twice for the null comparisons, which neither throw. Only missing.equals(...) throws a NullPointerException. The switch prices print SMALL costs 18 through EXTRA_LARGE costs 22, and describe prints small, XL, ships separately and no size chosen. Without case null, price(null) throws, like every switch before Java 21. Delete the EXTRA_LARGE case from price and it stops compiling: the switch expression does not cover all possible input values. That check is a reason to list every constant instead of reaching for default: adding a constant later points you at every switch that needs updating. Likewise, Size.LARGE == Color.RED fails with incomparable types: Main.Size and Main.Color, while Size.LARGE.equals(Color.RED) compiles and quietly returns false.

Frequently asked questions

How do I get an enum value from a string in Java?

Call the enum's generated valueOf method: Size.valueOf("MEDIUM") returns Size.MEDIUM. The string must match the constant's name exactly, including case, or it throws IllegalArgumentException: No enum constant Main.Size.medium. A null string throws NullPointerException: Name is null. For input you don't control, wrap the lookup in a helper that returns Optional<Size>.

Should I compare Java enums with == or equals()?

Use ==. There is only ever one instance of each constant, so both give the same result, but == is null-safe (null == Size.LARGE is false, while missing.equals(Size.LARGE) throws NullPointerException) and it is checked at compile time: Size.LARGE == Color.RED fails with incomparable types, where equals compiles and returns false.

How do I loop over all values of an enum?

Use a for-each loop over Size.values(), which returns the constants in declaration order. EnumSet.allOf(Size.class) gives the same constants as a Set, and EnumSet.range(Size.MEDIUM, Size.EXTRA_LARGE) a slice of them. To get the names as a list, Arrays.stream(Size.values()).map(Enum::name).toList() prints [SMALL, MEDIUM, LARGE, EXTRA_LARGE] (toList() needs Java 16+).

How do I make Enum.valueOf case-insensitive?

There is no built-in option. Either loop over values() and return the constant whose name().equalsIgnoreCase(input), or call valueOf(input.strip().toUpperCase(Locale.ROOT)) inside a try/catch. Always pass Locale.ROOT: with a Turkish default locale, "medium".toUpperCase() is MEDİUM, which matches no constant.

What is the difference between name() and toString() on an enum?

name() returns the identifier exactly as declared and is final, so it always works with valueOf. toString() returns the same string by default, but an enum can override it to return a display label. After overriding it to "Large", Size.valueOf(Size.LARGE.toString()) throws No enum constant Main.Size.Large. Persist and transmit name() (or your own code field) and use toString() for display.

How do I convert an int to an enum in Java?

If the int is the ordinal, index into the array: Size.values()[2] is LARGE, and an index past the end throws ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4. Ordinals shift when someone reorders or inserts constants, so don't store them. For stable numbers such as HTTP status codes, give the enum an int field and look it up in a static map, as in section 3.

Run it yourself

Open any of these in the full Java editor to tweak, run and share.

Java playground