Jak uzyskać wartość enum z wartości łańcuchowej w Javie?

Inne rozwiązanie, jeśli tekst nie jest taki sam jak wartość wyliczenia:

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

Oto sprytne narzędzie, którego używam:

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

Wtedy w mojej klasie enum zwykle mam to, aby zapisać kilka wpisów:

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

Jeśli twoje liczby nie są wielkimi literami, po prostu zmień linię Enum.valueOf.

Szkoda, że nie mogę użyć T.class do Enum.valueOf, Ponieważ T jest kasowane.

Powinieneś też być ostrożny ze swoją sprawą. Pozwól, że wyjaśnię: Robienie Blah.valueOf("A") działa, ale {[1] } nie zadziała. Wtedy znowu Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) zadziałałoby.

Edit
Zmieniono toUpperCase na toUpperCase(Locale.ENGLISH)na podstawie tc. komentarz i Java docs

Edit2 Na Androidzie powinieneś używać Locale.US, jak wskazuje sulai .

Użyj wzorca z Joshua Bloch, efektywna Java :

(uproszczone dla zwięzłości)

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

Zobacz też:

Oracle Java Example using Enum and Map of instances

Kolejność wykonywania bloków statycznych typu Enum

Jak mogę wyszukać enum Javy z jego wartości String

Oto metoda, która może to zrobić dla każdego Enum i jest niewrażliwa na wielkość liter.

/** 
 * 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()
    ));
}

Używanie Blah.valueOf(string) jest najlepsze, ale możesz również używać Enum.valueOf(Blah.class, string).

Jeśli nie chcesz pisać własnego narzędzia użyj biblioteki Google guava :

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

W przeciwieństwie do wbudowanej w Javę funkcji pozwala sprawdzić, czy A jest obecny w bla i nie rzuca wyjątku.

Możesz potrzebować tego:

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

Jeszcze Jeden Dodatek:

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

Zwróci ci wartość za pomocą Stringified Enum Name for np. jeśli podasz "PERSON" w fromEnumName zwróci ci wartość Enum tj. "Person"

W Javie 8 lub nowszej, używając strumieni :

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 fromText(String text) {
        return Arrays.stream(values())
          .filter(bl -> bl.text.equalsIgnoreCase(text))
          .findFirst()
          .orElse(null);
    }
}

Moje 2 grosze tutaj: używanie strumieni Java8 + sprawdzanie dokładnego ciągu:

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

** EDIT * *

Zmieniono nazwę funkcji na fromString() ponieważ nazwanie jej za pomocą tej konwencji, uzyskasz pewne korzyści z samego języka Java; na przykład:

1. bezpośrednia konwersja typów w adnotacji HeaderParam

Innym sposobem jest użycie implicit static method name() z Enum. name zwróci dokładny łańcuch użyty do utworzenia tego enum, który może być użyty do sprawdzenia podanego ciągu:

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

Testowanie:

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

//it will print B  B

Inspiracja: 10 przykładów Enum w Javie

Rozwiązanie przy użyciu bibliotek Guava. Metoda getPlanet () jest niewrażliwa na wielkość liter, więc getPlanet ("Merkury") zwróci planetę.Rtęć.

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

Aby dodać do poprzednich odpowiedzi i odnieść się do niektórych dyskusji wokół null i NPE używam opcji Guava do obsługi nieobecnych / nieprawidłowych przypadków. Działa to świetnie dla parsowania URI / parametr.

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

Dla tych, którzy nie są świadomi, oto więcej informacji na temat unikania null z opcjonalnym: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

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) Metoda zainspirowana kodem generowanym przez thrift, który wykorzystuje hashmapę.

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

}

W Javie 8 statyczny wzór mapy jest jeszcze łatwiejszy i jest to moja metoda. Jeśli chcesz użyć Enum z Jacksonem, możesz zastąpić toString i użyć tego zamiast nazwy, a następnie dodać adnotację za pomocą @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);
    }
}

java.lang.Enum definiuje kilka użytecznych metod, które są dostępne dla wszystkich typów wyliczeń w Javie:

• możesz użyć metody name(), aby uzyskać nazwę dowolnych stałych Enum. Literał Łańcuchowy używany do zapisu stałych enum jest ich nazwą.
• podobnie values() Metoda może być użyta do uzyskania tablicy wszystkich stałych Enum z typu Enum.
• i dla zadanego pytania, możesz użyć metody valueOf() do konwersji dowolnego ciągu znaków na stałą Enum w Javie, jak pokazano poniżej.

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

W ten fragment kodu, metoda valueOf() zwraca stałą Enum Gender.Mężczyzna, wywołujący imię na tym zwraca "MALE".

Apache ' s commons-Lang library has a static function org.Apacz.commons.lang3.EnumUtils.getEnum , które mapuje Łańcuch do typu Enum. Ta sama odpowiedź co Geoffreys, ale po co toczyć własną, skoro już jest na wolności.

Dodawanie do najwyżej ocenianej odpowiedzi, z pomocnym narzędziem...

valueOf() rzuca dwa różne wyjątki w przypadkach, gdy nie podoba mu się jego wejście.

• IllegalArgumentException
• NullPointerExeption

Jeśli Twoje wymagania są takie, że nie masz żadnej gwarancji, że Twój ciąg znaków na pewno będzie pasował do wartości enum, na przykład jeśli dane ciągu pochodzą z bazy danych i mogą zawierać starą wersję enum, będziesz musiał obsługiwać je często...

Więc oto metoda wielokrotnego użytku, którą napisałem, która pozwala nam zdefiniować domyślne Enum, które ma być zwrócone, jeśli przekazywany ciąg znaków nie pasuje.

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

Użyj go tak:

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
}

Kolejne narzędzie przechwytujące w odwrotny sposób. Używając wartości, która identyfikuje to Enum, a nie z jego nazwy.

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

Przykład:

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") zwraca Foo.THREE, ponieważ użyje getValue, aby dopasować" drei", która jest unikalną publiczną, nie ostateczną i nie statyczną metodą w Foo. W przypadku, gdy Foo ma więcej niż na publicznej, nie ostatecznej i nie statycznej metody, na przykład {[5] } która zwraca "drei", można użyć drugiej metody: EnumUtil.from(Foo.class, "drei", "getTranslate").

O czym?

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

Jako switch - wersja nie została jeszcze wymieniona wprowadzam ją (ponowne wykorzystanie enum 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);
      }
    }
  }

Ponieważ nie daje to żadnej dodatkowej wartości metodzie valueOf(String name), sensowne jest zdefiniowanie dodatkowej metody tylko wtedy, gdy chcemy mieć inne zachowanie. Jeśli nie chcemy podnosić IllegalArgumentException możemy zmienić implementację na:

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

Podając wartość domyślną zachowujemykontrakt z Enum.valueOf(String name) bez rzucania IllegalArgumentException w taki sposób, że w żadnym wypadku null nie jest zwrócony. Dlatego rzucamy NullPointerException Jeśli nazwa jest null i w przypadku default jeśli defaultValue jest null. Tak działa valueOfOrDefault.

To podejście przyjmuje projekt Map-Interface, który dostarcza metodę Map.getOrDefault(Object key, V defaultValue) począwszy od Java 8.

Lubię używać tego rodzaju procesu do przetwarzania poleceń jako ciągów znaków do wyliczeń. Zwykle mam jedno z wyliczeń jako "nieznane", więc pomaga mieć to zwrócone, gdy inne nie są znalezione (nawet przy niewrażliwości na wielkość liter), a nie null (co oznacza, że nie ma wartości). Dlatego stosuję takie podejście.

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