Wie erhalte ich einen Aufzählungswert aus einem Zeichenfolgenwert in Java?

Angenommen, ich habe eine Aufzählung, die gerecht ist

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

und ich möchte zum Beispiel den Aufzählungswert eines Strings finden, "A"der wäre Blah.A. Wie wäre das möglich?

Ist das Enum.valueOf()die Methode, die ich brauche? Wenn ja, wie würde ich das verwenden?

Ja, Blah.valueOf("A")werde dir geben Blah.A.

Beachten Sie, dass der Name genau übereinstimmen muss, einschließlich Groß- Blah.valueOf("a")und Kleinschreibung: und Blah.valueOf("A ")beide werfen eine IllegalArgumentException.

Die statischen Methoden valueOf()und values()werden zur Kompilierungszeit erstellt und erscheinen nicht im Quellcode. Sie erscheinen jedoch in Javadoc; Dialog.ModalityTypezeigt zum Beispiel beide Methoden.

Eine andere Lösung, wenn der Text nicht mit dem Aufzählungswert übereinstimmt:

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

Hier ist ein nützliches Dienstprogramm, das ich verwende:

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

Dann habe ich in meiner Enum-Klasse normalerweise Folgendes, um etwas Tippen zu sparen:

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

Wenn Ihre Aufzählungen nicht alle Großbuchstaben sind, ändern Sie einfach die Enum.valueOfZeile.

Schade , kann ich nicht verwenden , T.classfür Enum.valueOfwie Tgelöscht wird.

Verwenden Sie das Muster von Joshua Bloch, Effective Java :

(der Kürze halber vereinfacht)

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

Siehe auch:

Oracle Java-Beispiel mit Enum und Map of Instances

Ausführungsreihenfolge von statischen Blöcken in einem Enum-Typ

Wie kann ich eine Java-Enumeration anhand ihres String-Werts nachschlagen?

Sie sollten auch mit Ihrem Fall vorsichtig sein. Lassen Sie mich erklären: Blah.valueOf("A")Arbeiten funktioniert, wird aber Blah.valueOf("a")nicht funktionieren. Dann Blah.valueOf("a".toUpperCase(Locale.ENGLISH))würde wieder funktionieren.

edit
Geändert toUpperCasezu toUpperCase(Locale.ENGLISH)basierend auf tc. Kommentar und die Java-Dokumente

edit2 Auf Android solltest du verwenden Locale.US, wie Sulai betont .

Hier ist eine Methode, die dies für jede Aufzählung tun kann und bei der die Groß- und Kleinschreibung nicht berücksichtigt wird.

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

Verwenden Blah.valueOf(string)ist am besten, aber Sie können auch verwenden Enum.valueOf(Blah.class, string).

In Java 8 oder höher mit 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();
    }
}

Wenn Sie kein eigenes Dienstprogramm schreiben möchten, verwenden Sie das von Google Guave Bibliothek:

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

Im Gegensatz zur integrierten Java-Funktion können Sie überprüfen, ob A in Blah vorhanden ist, und keine Ausnahme auslösen.

Meine 2 Cent hier: Verwenden von Java8 Streams + Überprüfen einer genauen Zeichenfolge:

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

** BEARBEITEN **

Wenn Sie die Funktion in umbenannt haben, fromString()da Sie sie mit dieser Konvention benannt haben, profitieren Sie von der Java-Sprache selbst. zum Beispiel:

1. Direkte Konvertierung von Typen in der HeaderParam-Annotation

Möglicherweise benötigen Sie dazu:

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

Noch eine Ergänzung:

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

Dies gibt Ihnen den Wert durch einen Stringified Enum-Namen zurück. Wenn Sie beispielsweise "PERSON" in fromEnumName angeben, erhalten Sie den Wert von Enum, dh "Person".

Eine andere Möglichkeit, dies zu tun, ist die implizite statische Methode name()von Enum. name gibt die genaue Zeichenfolge zurück, die zum Erstellen dieser Aufzählung verwendet wurde, mit der die angegebene Zeichenfolge überprüft werden kann:

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

Testen:

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

//it will print B  B

Inspiration: 10 Beispiele für Enum in Java

Lösung mit Guava-Bibliotheken. Bei der Methode getPlanet () wird die Groß- und Kleinschreibung nicht berücksichtigt, daher gibt getPlanet ("MerCUrY") Planet.MERCURY zurück.

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

Um die vorherigen Antworten zu ergänzen und einige der Diskussionen um Nullen und NPE anzusprechen, verwende ich Guava-Optionen, um fehlende / ungültige Fälle zu behandeln. Dies funktioniert hervorragend für die URI- / Parameteranalyse.

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

Für diejenigen, die es nicht wissen, finden Sie hier weitere Informationen zum Vermeiden von Null mit Optional: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

In Java 8 ist das statische Kartenmuster noch einfacher und meine bevorzugte Methode. Wenn Sie die Aufzählung mit Jackson verwenden möchten, können Sie toString überschreiben und diese anstelle des Namens verwenden und dann mit kommentieren@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) -Methode, inspiriert von sparsam erzeugtem Code, der eine Hashmap verwendet.

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 ist sehr nützlich. Ich habe Enumviel verwendet, um eine Beschreibung für einige Felder in verschiedenen Sprachen hinzuzufügen, wie im folgenden Beispiel:

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

Anschließend können Sie die Beschreibung dynamisch anhand des an die getDescription(String lang)Methode übergebenen Sprachcodes abrufen , z. B.:

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

Wie wäre es mit?

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 definiert mehrere nützliche Methoden, die für alle Aufzählungstypen in Java verfügbar sind:

• Sie können die name()Methode verwenden, um den Namen aller Enum-Konstanten abzurufen. String-Literal zum Schreiben von Enum-Konstanten ist ihr Name.
• In ähnlicher values()Weise kann die Methode verwendet werden, um ein Array aller Enum-Konstanten von einem Enum-Typ abzurufen.
• Und für die gestellte Frage können Sie eine valueOf()Methode verwenden, um einen beliebigen String in eine Enum-Konstante in Java zu konvertieren, wie unten gezeigt.

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

In diesem valueOf()Codeausschnitt gibt die Methode eine Enum-Konstante Gender.MALE zurück, die den Namen aufruft, der zurückgegeben wird "MALE".

Die commons-lang- Bibliothek von Apache verfügt über eine statische Funktion org.apache.commons.lang3.EnumUtils.getEnum, die Ihrem Enum-Typ einen String zuordnet . Dieselbe Antwort im Wesentlichen wie bei Geoffreys, aber warum sollten Sie Ihre eigenen rollen, wenn es schon in freier Wildbahn ist?

Hinzufügen zu der am besten bewerteten Antwort mit einem hilfreichen Dienstprogramm ...

valueOf() löst zwei verschiedene Ausnahmen aus, wenn die Eingabe nicht gefällt.

• IllegalArgumentException
• NullPointerExeption

Wenn Ihre Anforderungen so sind, dass Sie keine Garantie dafür haben, dass Ihr String definitiv mit einem Aufzählungswert übereinstimmt, z. B. wenn die String-Daten aus einer Datenbank stammen und eine alte Version der Aufzählung enthalten könnten, müssen Sie diese verarbeiten häufig...

Hier ist eine wiederverwendbare Methode, mit der wir eine Standard-Enum definieren können, die zurückgegeben werden soll, wenn der von uns übergebene String nicht übereinstimmt.

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

Verwenden Sie es so:

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
}

Da eine switch-Version noch nicht erwähnt wurde, stelle ich sie vor (Wiederverwendung der Aufzählung von 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);
      }
    }
  }

Da dies der valueOf(String name)Methode keinen zusätzlichen Wert verleiht , ist es nur dann sinnvoll, eine zusätzliche Methode zu definieren, wenn wir ein anderes Verhalten wünschen. Wenn wir keine erhöhen möchten, IllegalArgumentExceptionkönnen wir die Implementierung ändern in:

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

Durch die Angabe eines Standardwertes behalten wir den Vertrag bei, Enum.valueOf(String name)ohne einen IllegalArgumentException auf diese Weise zu werfen , der in keinem Fall nullzurückgegeben wird. Deshalb werfen wir ein NullPointerExceptionif der Name ist nullund falls defaultif defaultValueist null. So valueOfOrDefaultfunktioniert es.

Dieser Ansatz übernimmt das Design der Map-Interface, die eine Methode Map.getOrDefault(Object key, V defaultValue)ab Java 8 bereitstellt .

Ein weiteres Dienstprogramm, das in umgekehrter Weise erfasst. Verwenden eines Werts, der diese Aufzählung identifiziert, nicht anhand ihres Namens.

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

Beispiel:

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")Gibt zurück Foo.THREE, da es verwendet wird, getValueum mit "drei" übereinzustimmen, einer eindeutigen öffentlichen, nicht endgültigen und nicht statischen Methode in Foo. Wenn Foo beispielsweise mehr als eine öffentliche, keine endgültige und keine statische Methode hat, getTranslatedie "drei" zurückgibt, kann die andere Methode verwendet werden : EnumUtil.from(Foo.class, "drei", "getTranslate").

Kotlin-Lösung

Erstellen Sie eine Nebenstelle und rufen Sie dann an valueOf<MyEnum>("value"). Wenn der Typ ungültig ist, erhalten Sie null und müssen damit umgehen

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

Alternativ können Sie einen Standardwert festlegen, aufrufen valueOf<MyEnum>("value", MyEnum.FALLBACK)und eine Nullantwort vermeiden. Sie können Ihre spezifische Aufzählung so erweitern, dass die Standardeinstellung automatisch ist

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

Oder wenn Sie beides wollen, machen Sie das zweite:

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

Ich verwende diese Art von Prozess gerne, um Befehle als Zeichenfolgen in Aufzählungen zu analysieren. Normalerweise habe ich eine der Aufzählungen als "unbekannt", daher ist es hilfreich, diese zurückzugeben, wenn die anderen nicht gefunden werden (auch wenn die Groß- und Kleinschreibung nicht berücksichtigt wird) und nicht null (dh es gibt keinen Wert). Daher verwende ich diesen Ansatz.

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

Der schnellste Weg, um den Namen von enum zu erhalten, besteht darin, beim Start der Anwendung eine Karte mit Aufzählungstext und -wert zu erstellen. Um den Namen zu erhalten, rufen Sie die Funktion Blah.getEnumName () auf:

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