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.

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); 
    }
}

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".

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:

 (role.equals()) {
    
}

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) {
     (input == ) {
         ;
    }

     {
         Blah.valueOf(input.trim().toUpperCase());
    }  (IllegalArgumentException e) {
         ;
    }
}

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:

// 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 {
         Blah.valueOf(input.trim().toUpperCase());
    }  (IllegalArgumentException e) {
         ;
    }
}

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()?

• 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.