public static MyEnum getFromValue(String value) {
    MyEnum resp = null;
    MyEnum nodes[] = values();
    for(int i = 0; i < nodes.length; i++) {
        if(nodes[i].value.equals(value)) {
            resp = nodes[i];
            break;
        }
    }
    return resp;
}

如果您不想编写自己的实用程序，请使用Google的番石榴库：

Enums.getIfPresent(Blah.class, "A")

与内置Java函数不同，它让您检查Blah中是否存在A，并且不会引发异常。

你也应该小心处理你的案子。让我解释一下：Blah.valueOf（“A”）有效，但Blah.valueOf（“A”）无效。然后Blah.valueOf（“a”.toUpperCase（Locale.ENGLISH））也会起作用。

在Android上，你应该使用Locale.US，正如苏拉指出的那样。

java.lang.Enum定义了几种有用的方法，可用于java中的所有枚举类型：

可以使用name（）方法获取任何Enum常量的名称。用于编写枚举常量的字符串文字是它们的名称。类似地，values（）方法可用于从Enum类型获取所有Enum常量的数组。对于所问的问题，您可以使用valueOf（）方法在Java中将任何String转换为Enum常量，如下所示。

public class EnumDemo06 {
    public static void main(String args[]) {
        Gender fromString = Gender.valueOf("MALE");
        System.out.println("Gender.MALE.name() : " + fromString.name());
    }

    private enum Gender {
        MALE, FEMALE;
    }
}

Output:
Gender.MALE.name() : MALE

在此代码段中，valueOf（）方法返回一个Enum常量Gender.MALE，以及返回“MALE”的调用名称。

另一个实用程序以相反的方式捕获。使用标识该Enum的值，而不是从其名称。

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.EnumSet;

public class EnumUtil {

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose a 
     * public method return value of this Enum is 
     * equal to <code>valor</code>.<br/>
     * Such method should be unique public, not final and static method 
     * declared in Enum.
     * In case of more than one method in match those conditions
     * its first one will be chosen.
     * 
     * @param enumType
     * @param value
     * @return 
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value) {
        String methodName = getMethodIdentifier(enumType);
        return from(enumType, value, methodName);
    }

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose  
     * public method <code>methodName</code> return is 
     * equal to <code>value</code>.<br/>
     *
     * @param enumType
     * @param value
     * @param methodName
     * @return
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value, String methodName) {
        EnumSet<E> enumSet = EnumSet.allOf(enumType);
        for (E en : enumSet) {
            try {
                String invoke = enumType.getMethod(methodName).invoke(en).toString();
                if (invoke.equals(value.toString())) {
                    return en;
                }
            } catch (Exception e) {
                return null;
            }
        }
        return null;
    }

    private static String getMethodIdentifier(Class<?> enumType) {
        Method[] methods = enumType.getDeclaredMethods();
        String name = null;
        for (Method method : methods) {
            int mod = method.getModifiers();
            if (Modifier.isPublic(mod) && !Modifier.isStatic(mod) && !Modifier.isFinal(mod)) {
                name = method.getName();
                break;
            }
        }
        return name;
    }
}

例子：

public enum Foo {
    ONE("eins"), TWO("zwei"), THREE("drei");

    private String value;

    private Foo(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

EnumUtil.from（Foo.class，“drei”）返回Foo.THREE，因为它将使用getValue来匹配“drei“，这是Foo中唯一的公共方法，不是final方法，也不是静态方法。如果Foo在public、非final和非静态方法上有多个，例如，getTranslate返回“drei”，则可以使用另一个方法：EnumUtil.from（Foo.class，“drei”，“getTranslate”）。

我的两分钱在这里：使用Java 8 Streams并检查精确的字符串：

public enum MyEnum {
    VALUE_1("Super"),
    VALUE_2("Rainbow"),
    VALUE_3("Dash"),
    VALUE_3("Rocks");

    private final String value;

    MyEnum(String value) {
        this.value = value;
    }

    /**
     * @return the Enum representation for the given string.
     * @throws IllegalArgumentException if unknown string.
     */
    public static MyEnum fromString(String s) throws IllegalArgumentException {
        return Arrays.stream(MyEnum.values())
                .filter(v -> v.value.equals(s))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("unknown value: " + s));
    }
}

我将函数重命名为fromString（），因为使用该约定命名它，您将从Java语言本身获得一些好处；例如：

在HeaderParam注释处直接转换类型