Как получить значение перечисления из строкового значения в Java?

Скажем, у меня есть перечисление, которое просто

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

и я хотел бы найти значение перечисления строки, например, "A"который будет Blah.A. Как это было бы возможно сделать?

Является ли Enum.valueOf()метод , который я нужен? Если так, как бы я использовал это?

Да, Blah.valueOf("A")даст вам Blah.A.

Обратите внимание, что имя должно быть точно совпадает, включая регистр: Blah.valueOf("a")и Blah.valueOf("A ")оба бросают IllegalArgumentException.

Статические методы valueOf()и values()создаются во время компиляции и не появляются в исходном коде. Они действительно появляются в Javadoc, хотя; например, Dialog.ModalityTypeпоказывает оба метода.

Другое решение, если текст не совпадает со значением перечисления:

public enum Blah {
    A("text1"),
    B("text2"),
    C("text3"),
    D("text4");

    private String text;

    Blah(String text) {
        this.text = text;
    }

    public String getText() {
        return this.text;
    }

    public static Blah fromString(String text) {
        for (Blah b : Blah.values()) {
            if (b.text.equalsIgnoreCase(text)) {
                return b;
            }
        }
        return null;
    }
}

Вот изящная утилита, которую я использую:

/**
 * A common method for all enums since they can't have another base class
 * @param <T> Enum type
 * @param c enum type. All enums must be all caps.
 * @param string case insensitive
 * @return corresponding enum, or null
 */
public static <T extends Enum<T>> T getEnumFromString(Class<T> c, String string) {
    if( c != null && string != null ) {
        try {
            return Enum.valueOf(c, string.trim().toUpperCase());
        } catch(IllegalArgumentException ex) {
        }
    }
    return null;
}

Затем в моем классе enum я обычно сохраняю набор текста:

public static MyEnum fromString(String name) {
    return getEnumFromString(MyEnum.class, name);
}

Если ваши перечисления не все заглавные, просто измените Enum.valueOfстроку.

Жаль , я не могу использовать T.classдля , Enum.valueOfкак Tстирается.

Используйте образец из Джошуа Блоха, Эффективная Java :

(упрощено для краткости)

enum MyEnum {
    ENUM_1("A"),
    ENUM_2("B");

    private String name;

    private static final Map<String,MyEnum> ENUM_MAP;

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

    public String getName() {
        return this.name;
    }

    // Build an immutable map of String name to enum pairs.
    // Any Map impl can be used.

    static {
        Map<String,MyEnum> map = new ConcurrentHashMap<String, MyEnum>();
        for (MyEnum instance : MyEnum.values()) {
            map.put(instance.getName(),instance);
        }
        ENUM_MAP = Collections.unmodifiableMap(map);
    }

    public static MyEnum get (String name) {
        return ENUM_MAP.get(name);
    }
}

Также см:

Пример Oracle Java с использованием Enum и Map of instance

Порядок выполнения статических блоков в типе Enum

Как я могу найти перечисление Java из его значения String

Вы также должны быть осторожны с вашим делом. Позвольте мне объяснить: делать Blah.valueOf("A")дела, но Blah.valueOf("a")не будет работать. Тогда снова Blah.valueOf("a".toUpperCase(Locale.ENGLISH))будет работать.

изменить
Изменено toUpperCaseна toUpperCase(Locale.ENGLISH)основе тс. комментарий и документы Java

edit2 На Android вы должны использовать Locale.US, как указывает sulai .

Вот метод, который может сделать это для любого Enum и нечувствителен к регистру.

/** 
 * Finds the value of the given enumeration by name, case-insensitive. 
 * Throws an IllegalArgumentException if no match is found.  
 **/
public static <T extends Enum<T>> T valueOfIgnoreCase(
        Class<T> enumeration, String name) {

    for (T enumValue : enumeration.getEnumConstants()) {
        if (enumValue.name().equalsIgnoreCase(name)) {
            return enumValue;
        }
    }

    throw new IllegalArgumentException(String.format(
        "There is no value with name '%s' in Enum %s",
        name, enumeration.getName()
    ));
}

Использование Blah.valueOf(string)лучше, но вы также можете использовать Enum.valueOf(Blah.class, string).

В Java 8 или более поздней версии , используя Streams :

public enum Blah
{
    A("text1"),
    B("text2"),
    C("text3"),
    D("text4");

    private String text;

    Blah(String text) {
        this.text = text;
    }

    public String getText() {
        return this.text;
    }

    public static Optional<Blah> fromText(String text) {
        return Arrays.stream(values())
          .filter(bl -> bl.text.equalsIgnoreCase(text))
          .findFirst();
    }
}

Если вы не хотите писать свою собственную утилиту, используйте Google гуайява библиотека:

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

В отличие от встроенной функции Java, она позволяет вам проверить, присутствует ли A в Blah и не выдает ли исключение.

Мои 2 цента здесь: использование потоков Java8 + проверка точной строки:

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; например:

1. Прямое преобразование типов в аннотации HeaderParam

Вам может понадобиться это:

public enum ObjectType {
    PERSON("Person");

    public String parameterName;

    ObjectType(String parameterName) {
        this.parameterName = parameterName;
    }

    public String getParameterName() {
        return this.parameterName;
    }

    //From String method will return you the Enum for the provided input string
    public static ObjectType fromString(String parameterName) {
        if (parameterName != null) {
            for (ObjectType objType : ObjectType.values()) {
                if (parameterName.equalsIgnoreCase(objType.parameterName)) {
                    return objType;
                }
            }
        }
        return null;
    }
}

Еще одно дополнение:

   public static String fromEnumName(String parameterName) {
        if (parameterName != null) {
            for (DQJ objType : DQJ.values()) {
                if (parameterName.equalsIgnoreCase(objType.name())) {
                    return objType.parameterName;
                }
            }
        }
        return null;
    }

Это вернет вам значение по строковому имени Enum. Например, если вы укажете «PERSON» в fromEnumName, он вернет вам значение Enum, то есть «Person»

Еще один способ сделать это с помощью неявного статического метода name()Enum. name возвращает точную строку, использованную для создания этого перечисления, которое можно использовать для проверки по предоставленной строке:

public enum Blah {

    A, B, C, D;

    public static Blah getEnum(String s){
        if(A.name().equals(s)){
            return A;
        }else if(B.name().equals(s)){
            return B;
        }else if(C.name().equals(s)){
            return C;
        }else if (D.name().equals(s)){
            return D;
        }
        throw new IllegalArgumentException("No Enum specified for this string");
    }
}

Тестирование:

System.out.println(Blah.getEnum("B").name());

//it will print B  B

вдохновение: 10 примеров Enum на Java

Решение с использованием библиотек Guava. Метод getPlanet () нечувствителен к регистру, поэтому getPlanet ("MerCUrY") вернет Planet.MERCURY.

package com.universe.solarsystem.planets;
import org.apache.commons.lang3.StringUtils;
import com.google.common.base.Enums;
import com.google.common.base.Optional;

//Pluto and Eris are dwarf planets, who cares!
public enum Planet {
   MERCURY,
   VENUS,
   EARTH,
   MARS,
   JUPITER,
   SATURN,
   URANUS,
   NEPTUNE;

   public static Planet getPlanet(String name) {
      String val = StringUtils.trimToEmpty(name).toUpperCase();
      Optional <Planet> possible = Enums.getIfPresent(Planet.class, val);
      if (!possible.isPresent()) {
         throw new IllegalArgumentException(val + "? There is no such planet!");
      }
      return possible.get();
   }
}

Чтобы добавить к предыдущим ответам и обсудить некоторые дискуссии вокруг нулей и NPE, я использую дополнительные возможности Guava для обработки отсутствующих / недействительных случаев. Это прекрасно работает для разбора URI / параметров.

public enum E {
    A,B,C;
    public static Optional<E> fromString(String s) {
        try {
            return Optional.of(E.valueOf(s.toUpperCase()));
        } catch (IllegalArgumentException|NullPointerException e) {
            return Optional.absent();
        }
    }
}

Для тех, кто не знает, вот еще некоторая информация о том, как избежать нуля с помощью Необязательно: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

В Java 8 шаблон статической карты еще проще и является моим предпочтительным методом. Если вы хотите использовать Enum с Джексоном, вы можете переопределить toString и использовать его вместо имени, а затем аннотировать@JsonValue

public enum MyEnum {
    BAR,
    BAZ;
    private static final Map<String, MyEnum> MAP = Stream.of(MyEnum.values()).collect(Collectors.toMap(Enum::name, Function.identity()));
    public static MyEnum fromName(String name){
        return MAP.get(name);
    }
}

public enum MyEnumForJson {
    BAR("bar"),
    BAZ("baz");
    private static final Map<String, MyEnumForJson> MAP = Stream.of(MyEnumForJson.values()).collect(Collectors.toMap(Object::toString, Function.identity()));
    private final String value;

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

    @JsonValue
    @Override
    public String toString() {
        return value;
    }

    public static MyEnumForJson fromValue(String value){
        return MAP.get(value);
    }
}

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

O (1) метод, основанный на сгенерированном коде, который использует хэш-карту.

public enum USER {
        STUDENT("jon",0),TEACHER("tom",1);

        private static final Map<String, Integer> map = new HashMap<>();

        static {
                for (USER user : EnumSet.allOf(USER.class)) {
                        map.put(user.getTypeName(), user.getIndex());
                }
        }

        public static int findIndexByTypeName(String typeName) {
                return map.get(typeName);
        }

        private USER(String typeName,int index){
                this.typeName = typeName;
                this.index = index;
        }
        private String typeName;
        private int index;
        public String getTypeName() {
                return typeName;
        }
        public void setTypeName(String typeName) {
                this.typeName = typeName;
        }
        public int getIndex() {
                return index;
        }
        public void setIndex(int index) {
                this.index = index;
        }

}

Enum очень полезен, я много использовал Enumдля добавления описания некоторых полей на разных языках, как в следующем примере:

public enum Status {

    ACT(new String[] { "Accepted", "مقبول" }),
    REJ(new String[] { "Rejected", "مرفوض" }),
    PND(new String[] { "Pending", "في الانتظار" }),
    ERR(new String[] { "Error", "خطأ" }),
    SNT(new String[] { "Sent", "أرسلت" });

    private String[] status;

    public String getDescription(String lang) {
        return lang.equals("en") ? status[0] : status[1];
    }

    Status(String[] status) {
        this.status = status;
    }
}

И затем вы можете получить описание динамически на основе кода языка, переданного getDescription(String lang)методу, например:

String statusDescription = Status.valueOf("ACT").getDescription("en");

Что о?

public enum MyEnum {
    FIRST,
    SECOND,
    THIRD;

    public static Optional<MyEnum> fromString(String value){
        try{
            return Optional.of(MyEnum.valueOf(value));
        }catch(Exception e){
            return Optional.empty();
        }
    }
}

java.lang.Enum определяет несколько полезных методов, которые доступны для всех типов перечисления в Java:

• Вы можете использовать name()метод, чтобы получить имя любой константы Enum. Строковый литерал, используемый для записи констант enum, является их именем.
• Аналогичным образом values()метод можно использовать для получения массива всех констант Enum из типа Enum.
• А для заданного вопроса вы можете использовать valueOf()метод для преобразования любой String в Enum константу в Java, как показано ниже.

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

Библиотека Apache commons-lang имеет статическую функцию org.apache.commons.lang3.EnumUtils.getEnum, которая сопоставляет строку с вашим типом Enum. Тот же ответ, что и у Джеффриса, но зачем бросать свой, когда он уже в дикой природе.

Добавление к ответу с самым высоким рейтингом, с полезной утилитой ...

valueOf() выдает два разных исключения в тех случаях, когда ему не нравится его ввод.

• IllegalArgumentException
• NullPointerExeption

Если ваши требования таковы, что у вас нет никаких гарантий, что ваша строка будет точно соответствовать значению перечисления, например, если данные строки поступают из базы данных и могут содержать старую версию перечисления, вам нужно будет обработать эти довольно часто...

Итак, вот метод многократного использования, который я написал, который позволяет нам определить Enum по умолчанию, который будет возвращен, если передаваемая строка не совпадает.

private static <T extends Enum<T>> T valueOf( String name , T defaultVal) {
        try {
            return Enum.valueOf(defaultVal.getDeclaringClass() , name);
        } catch (IllegalArgumentException | NullPointerException e) {
            return defaultVal;
        }
    }

Используйте это так:

public enum MYTHINGS {
    THINGONE,
    THINGTWO
}

public static void main(String [] asd) {
  valueOf("THINGTWO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGTWO
  valueOf("THINGZERO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGONE
}

Поскольку switch-версия еще не упоминалась, я представляю ее (повторно используя перечисление OP):

  private enum Blah {
    A, B, C, D;

    public static Blah byName(String name) {
      switch (name) {
        case "A":
          return A;
        case "B":
          return B;
        case "C":
          return C;
        case "D":
          return D;
        default:
          throw new IllegalArgumentException(
            "No enum constant " + Blah.class.getCanonicalName() + "." + name);
      }
    }
  }

Поскольку это не дает никакой дополнительной ценности valueOf(String name)методу, имеет смысл определять дополнительный метод, только если мы хотим иметь другое поведение. Если мы не хотим поднимать, IllegalArgumentExceptionмы можем изменить реализацию на:

  private enum Blah {
    A, B, C, D;

    public static Blah valueOfOrDefault(String name, Blah defaultValue) {
      switch (name) {
        case "A":
          return A;
        case "B":
          return B;
        case "C":
          return C;
        case "D":
          return D;
        default:
          if (defaultValue == null) {
            throw new NullPointerException();
          }
          return defaultValue;
      }
    }
  }

Предоставляя значение по умолчанию , мы соблюдаем контракт о Enum.valueOf(String name)не бросать IllegalArgumentException в такой манере , что ни в коем случае nullне возвращается. Поэтому мы бросаем, NullPointerExceptionесли имя nullи в случае, defaultесли defaultValueесть null. Вот так и valueOfOrDefaultработает.

Этот подход принимает дизайн Map-Interface, который обеспечивает метод Map.getOrDefault(Object key, V defaultValue)с Java 8.

Еще одна утилита захвата в обратном порядке. Использование значения, которое идентифицирует этот 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», который является уникальным public, не final и не статическим методом в Foo. В случае , если Foo имеет более чем на общественном, а не окончательным и не статический метод, например, getTranslateкоторый возвращает «драй», другой метод может быть использован: EnumUtil.from(Foo.class, "drei", "getTranslate").

Kotlin Solution

Создайте расширение, а затем позвоните valueOf<MyEnum>("value"). Если тип недействителен, вы получите ноль и должны обработать его

inline fun <reified T : Enum<T>> valueOf(type: String): T? {
    return try {
        java.lang.Enum.valueOf(T::class.java, type)
    } catch (e: Exception) {
        null
    }
}

Кроме того, вы можете установить значение по умолчанию, вызывая valueOf<MyEnum>("value", MyEnum.FALLBACK)и избегая нулевого ответа. Вы можете расширить свой конкретный enum, чтобы по умолчанию он был автоматическим

inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T {
    return try {
        java.lang.Enum.valueOf(T::class.java, type)
    } catch (e: Exception) {
        default
    }
}

Или, если вы хотите оба, сделайте второе:

inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T = valueOf<T>(type) ?: default

Мне нравится использовать этот процесс для анализа команд в виде строк в перечислениях. У меня обычно одно из перечислений как «неизвестное», поэтому полезно возвращать его, когда другие не найдены (даже без учета регистра), а не ноль (это означает, что значения нет). Поэтому я использую этот подход.

static <E extends Enum<E>> Enum getEnumValue(String what, Class<E> enumClass) {
    Enum<E> unknown=null;
    for (Enum<E> enumVal: enumClass.getEnumConstants()) {  
        if (what.compareToIgnoreCase(enumVal.name()) == 0) {
            return enumVal;
        }
        if (enumVal.name().compareToIgnoreCase("unknown") == 0) {
            unknown=enumVal;
        }
    }  
    return unknown;
}

Самый быстрый способ получить имя enum - это создать карту текста и значения enum при запуске приложения и получить имя, вызвав функцию Blah.getEnumName ():

public enum Blah {
    A("text1"),
    B("text2"),
    C("text3"),
    D("text4");

    private String text;
    private HashMap<String, String> map;
    Blah(String text) {
    this.text = text;
    }

    public String getText() {
      return this.text;
    }

    static{
      createMapOfTextAndName();
    }

    public static void createMapOfTextAndName() {
        map = new HashMap<String, String>();
        for (Blah b : Blah.values()) {
             map.put(b.getText(),b.name());
        }
    }
    public static String getEnumName(String text) {
        return map.get(text.toLowerCase());
    } 
}