How to Convert a String to an Enum in Java

By the end of this page, you will understand how to convert a String into an enum value in Java, when to use valueOf(), what errors it can throw, and how to safely handle invalid input in real programs.

In Java, an enum is a special type that represents a fixed set of constants. In your example, Blah can only be one of these values:

• A
• B
• C
• D

When you already have a string like "A" and want the matching enum constant Blah.A, Java provides a built-in method for that: valueOf().

For a specific enum type, the usual form is:

Blah value = Blah.valueOf("A");

This works because Java enums automatically get a static valueOf(String name) method.

Why this matters

Converting strings to enums is common in real programs because many values start as text:

• user input from forms
• query parameters in URLs
• configuration files
• JSON or CSV data
• command-line arguments
• database values

Enums help make code safer and clearer than using raw strings everywhere. Instead of checking for many string values manually, you can convert once and then work with a known set of valid constants.

Important rule

valueOf() matches the enum constant name exactly.

That means:

• "A" works
• "a" does not work
• " A " does not work unless trimmed first

If the string does not exactly match an enum constant name, Java throws an IllegalArgumentException.

Think of an enum like a row of labeled lockers:

• Locker A
• Locker B
• Locker C
• Locker D

A string is like a note with a locker label written on it.

If the note says exactly A, Java can open the locker labeled A and give you Blah.A.

If the note says a, A, or Z, Java cannot find an exact match and reports an error.

So valueOf() is basically: "Find me the enum constant whose name exactly matches this text."

The basic syntax is:

EnumType variable = EnumType.valueOf("CONSTANT_NAME");

With your enum:

public enum Blah {
    A, B, C, D
}

You can do this:

Blah result = Blah.valueOf("A");
System.out.println(result); // A

Full example

public class Main {
    public enum Blah {
        A, B, C, D
    }

    public static void main(String[] args) {
        String input = "A";
        Blah value = Blah.valueOf(input);
        System.out.println(value);      // A
        System.out.println(value == Blah.A); // true
    }
}

Safer example with validation

If the input may be invalid, wrap the conversion in a try-catch block:

public class Main {
    public enum Blah {
        A, B, C, D
    }

    public static void main(String[] args) {
        String input = "X";

        try {
            Blah value = Blah.valueOf(input);
            System.out.println("Valid enum: " + value);
        } catch (IllegalArgumentException e) {
            System.out.println("Invalid enum value: " + input);
        }
    }
}

Case-insensitive conversion

If you want to accept values like "a", normalize the string first:

String input = "a";
Blah value = Blah.valueOf(input.toUpperCase());
System.out.println(value); // A

If input might contain extra spaces:

String input = " a ";
Blah value = Blah.valueOf(input.trim().toUpperCase());
System.out.println(value); // A

Generic form

There is also a generic enum API:

Blah value = Enum.valueOf(Blah.class, "A");

This does the same thing, but Blah.valueOf("A") is shorter and more common when you already know the enum type.

Consider this code:

public enum Blah {
    A, B, C, D
}

public class Main {
    public static void main(String[] args) {
        String input = "B";
        Blah value = Blah.valueOf(input);
        System.out.println(value);
    }
}

Step by step

1. Java defines the enum Blah with four constants: A, B, C, and D.
2. In main, the variable input stores the string "B".
3. Blah.valueOf(input) is called.
4. Java looks through the enum constants of Blah for one whose name is exactly "B".
5. It finds Blah.B.
6. That enum value is assigned to the variable value.
7. System.out.println(value); prints B.

What if the input is invalid?

String input = "b";
Blah value = Blah.valueOf(input);

Now the steps change:

1. Java receives the string "b".
2. It looks for an enum constant named exactly "b".
3. The enum only contains A, B, C, and D.
4. No exact match is found.
5. Java throws IllegalArgumentException.

That is why input cleanup such as trim() and toUpperCase() is often useful when reading external data.

String-to-enum conversion appears often in everyday Java code.

API request parameters

A web API might receive:

status=ACTIVE

You can convert that string into an enum:

Status status = Status.valueOf(requestParam);

Configuration values

A config file might store:

environment=PRODUCTION

Then Java code can convert it to:

Environment env = Environment.valueOf(configValue);

Command-line tools

A CLI may accept modes like:

--mode=FAST

You convert that input to an enum instead of comparing strings manually.

CSV or database imports

When reading text data, enums provide a controlled set of valid values. This reduces bugs caused by typos or inconsistent strings.

Business rules

Instead of this:

if (role.equals("ADMIN")) {
    // ...
}

You can do this:

Role role = Role.valueOf(roleText);
if (role == Role.ADMIN) {
    // ...
}

This is easier to maintain and safer.

In real projects, developers rarely call valueOf() on raw input without checks. Common patterns include validation, normalization, and helper methods.

1. Normalize before converting

Blah value = Blah.valueOf(input.trim().toUpperCase());

Useful when input comes from users or external systems.

2. Guard clause for null values

valueOf() throws a NullPointerException if the input is null.

if (input == null) {
    throw new IllegalArgumentException("Input cannot be null");
}

Blah value = Blah.valueOf(input);

3. Safe parsing helper

Many codebases create a utility method instead of repeating try-catch everywhere.

public static Blah parseBlah(String input) {
    if (input == null) {
        return null;
    }

    try {
        return Blah.valueOf(input.trim().toUpperCase());
    } catch (IllegalArgumentException e) {
        return null;
    }
}

4. Returning Optional

A cleaner approach is to avoid returning null.

import java.util.Optional;

public static Optional<Blah> parseBlah(String input) {
    if (input == null) {
        return Optional.empty();
    }

    try {
        return Optional.of(Blah.valueOf(input.trim().toUpperCase()));
    } catch (IllegalArgumentException e) {
        return Optional.empty();
    }
}

5. Custom enum labels

Sometimes enum names are not the same as external values. In that case, valueOf() is not enough.

public enum Status {
    ACTIVE("active"),
    INACTIVE("inactive");

    private final String label;

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

    public String getLabel() {
        return label;
    }

    public static Status fromLabel(String text) {
        for (Status status : values()) {
            if (status.label.equalsIgnoreCase(text)) {
                return status;
            }
        }
        throw new IllegalArgumentException("Unknown status: " + text);
    }
}

This pattern is common when input strings are human-friendly or come from external formats.

Here are common mistakes beginners make when converting strings to enums.

1. Using the wrong case

Broken code:

Blah value = Blah.valueOf("a");

Problem:

• enum names are A, B, C, D
• "a" does not match "A"

Fix:

Blah value = Blah.valueOf("a".toUpperCase());

2. Forgetting to trim spaces

Broken code:

Blah value = Blah.valueOf(" A ");

Problem:

• the string includes spaces
• no enum constant is named " A "

Fix:

Blah value = Blah.valueOf(" A ".trim());

3. Not handling invalid input

Broken code:

String input = userInput();
Blah value = Blah.valueOf(input);

Problem:

• if the input is invalid, the program throws IllegalArgumentException

Fix:

try {
    Blah value = Blah.valueOf(input);
} catch (IllegalArgumentException e) {
    System.out.println("Invalid value");
}

4. Passing null

Broken code:

String input = null;
Blah value = Blah.valueOf(input);

Problem:

• this throws NullPointerException

Fix:

if (input != null) {
    Blah value = Blah.valueOf(input);
}

5. Assuming valueOf() uses custom labels

If your enum looks like this:

public enum Status {
    ACTIVE("active");

    private final String label;

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

Then this will not work:

Status s = Status.valueOf("active");

Why?

• valueOf() matches the enum constant name, which is ACTIVE
• it does not match the field value "active"

Fix:

• use Status.valueOf("ACTIVE")
• or write a custom lookup method

valueOf() vs custom lookup

When to use which

• Use Blah.valueOf() when input already matches enum constant names.
• Use a custom method when input comes from users, files, APIs, or other unreliable sources.

// Exact match
Blah value = Blah.valueOf("A");

// Generic form
Blah value2 = Enum.valueOf(Blah.class, "A");

// Safer input handling
Blah value3 = Blah.valueOf(input.trim().toUpperCase());

Rules

• valueOf() matches the enum constant name exactly.
• It is case-sensitive.
• It does not ignore whitespace.
• It does not use custom fields or labels.

Exceptions

• IllegalArgumentException if no matching enum constant exists
• NullPointerException if the input string is null

Safe parsing pattern

public static Blah parseBlah(String input) {
    if (input == null) {
        return null;
    }

    try {
        return Blah.valueOf(input.trim().toUpperCase());
    } catch (IllegalArgumentException e) {
        return null;
    }
}

Remember

• "A" -> works
• "a" -> fails unless normalized
• " A " -> fails unless trimmed
• "Z" -> fails

Is Enum.valueOf() the right method in Java?

Yes. If you want to convert a string to a matching enum constant by name, valueOf() is the standard built-in method.

What is the difference between Blah.valueOf() and Enum.valueOf()?

Blah.valueOf("A") is shorter and more common. Enum.valueOf(Blah.class, "A") is the generic version.

Does valueOf() ignore uppercase and lowercase?

No. It is case-sensitive. "A" works, but "a" does not unless you convert the string first.

What happens if the string does not match any enum constant?

Java throws an IllegalArgumentException.

What happens if I pass null to valueOf()?

Java throws a NullPointerException.

Can I convert a custom enum field like "active" using valueOf()?

No. valueOf() only matches the enum constant name, such as ACTIVE. For custom labels, write a separate lookup method.

Should I use enums instead of strings in Java?

Usually yes, when the value comes from a fixed set of known options. Enums are safer, clearer, and easier to maintain than raw strings.

• Java enums — The main feature being used here; enums define a fixed set of constants.
• Static methods in Java — valueOf() is a static method called on the enum type.
• Exception handling — Important because valueOf() can throw IllegalArgumentException and NullPointerException.
• String methods in Java — Methods like trim() and toUpperCase() are often used before enum conversion.
• Input validation — Real applications should validate or normalize user input before converting it.
• Optional in Java — Useful for safe parsing methods that avoid returning null.