Wie man einen enum-Wert einen string-Wert in Java?

Sagen, ich habe eine enum die nur

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

und ich möchte zu finden, die enum-Wert einen string, zum Beispiel "A" wäre Blah.A. Wie wäre es möglich, dies zu tun?

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

InformationsquelleAutor Malachi | 2009-03-02

2093

Ja, Blah.valueOf("A") geben Sie Blah.A.

Beachten Sie, dass der name muss ein genaue übereinstimmen, einschließlich groß: Blah.valueOf("a") und Blah.valueOf("A ") beide werfen ein IllegalArgumentException.

Den statischen Methoden valueOf() und values() erstellt werden, während der Kompilierung und werden nicht im Quellcode. Sie erscheinen im Javadoc, obwohl, zum Beispiel, - Dialog.ModalityType zeigt die beiden Methoden.
- Für Referenz, die Blah.valueOf("A") Methode Kleinschreibung und nicht dulden, überflüssige Leerzeichen, so ist die Alternative Lösung vorgeschlagen, die unter dem von @JoséMi.
- Myers, Da ist diese Antwort die meisten Stimmen bis weit, sollte ich verstehen, dass es gute Praxis ist die Definition eines enum und dessen String-Wert exakt gleich sein?
- Wenn Sie meinen, die toString() Wert, Nein, das würde ich nicht sagen. name() erhalten Sie die aktuellen definierten Namen der enum-Konstanten es sei denn, Sie überschreiben.
- Was genau meinst du mit "erzeugt bei der Kompilierung und werden nicht im source-code." ?
- Genauer gesagt, diese Methoden sind generierter oder synthetisiert) durch den compiler. Die tatsächliche enum Blah {...} definition sollte nicht versuchen zu erklären, seine eigenen values noch valuesOf. Es ist so, wie Sie schreiben können "AnyTypeName.class" obwohl Sie eigentlich nie erklärt, ein "Klasse" member-variable; der compiler macht alles Nur Arbeit. (Diese Antwort kann nicht mehr nützlich sein, um Sie 3 Monate später, aber nur für den Fall.)
- Super Antwort,--zusätzlich habe ich gefunden, indem ein paar kleine Hilfsmethoden enums hilft viel... Zum Beispiel, wenn Sie erstellen eine statische Karte von lower-case-Einträge im Konstruktor, dann können Sie fügen Sie eine Methode, sieht die enum in eine case-insensitive Weise, oder wandelt underbars zu Räumen, so dass user-input wie "Zweiter Eintrag", könnte die Zuordnung zu einer enum-SECOND_ENTRY.
- Warum hat @Brett Kommentar haben so viele Stimmen? Natürlich ist es groß-und Kleinschreibung und nicht dulden, überflüssige Leerzeichen, alles andere wäre verrückt.
- Nicht, dass wahnsinnig, da Leerzeichen nicht erlaubt ist Namen und, dass alle enum-Namen werden uppecase von Konvention. So eine tolerante lookup-Methode möglich ist, das Ergebnis bleibt einzigartig. Es kann jedoch vorkommen, erfordern sogar noch etwas toleranter werden und daher ist es am besten, um eine kanonische strenge version (und es gibt andere Probleme, wie uppercasing als locale-sensitive und was auch immer).
- Upvote, aber dieser Beitrag wäre noch besser, mit einer Erwähnung von Enum::name
InformationsquelleAutor Michael Myers
798

Andere Lösung, wenn der text nicht gleich auf die enumeration value:
```
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;
    }
}
```
- throw new IllegalArgumentException("No constant with text " + text + " found") wäre besser als return null.
- Jon Skeet würde nicht Zustimmen. stackoverflow.com/questions/1167982/...
- Konnte Sie enlight uns, warum null zurückgeben ist besser?
- Dieser Kommentar ist über die vorgeschlagene Antwort tatsächlich abfangen einer Ausnahme zu bestimmen, ob der string stellt einen gültigen enum-Wert. Sie müssen wahrscheinlich eine zweite Methode (z.B. isValid) für solch einen Anwendungsfall.
- in der Regel ist es eine gute Sache, um zu überprüfen, was die SONNE - Hoppla - Oracle tut sich in der gleichen situation. Und als Enum.valueOf() ist es zu zeigen IST best-practice zu werfen eine Ausnahme in diesem Fall. Denn es ist eine außergewöhnliche situation. "Performance-Optimierung" ist eine schlechte Ausrede, um unleserlicher code schreiben 😉
- Gut, Sie könnten auch Gebrauch machen von @Nullable-Anmerkung zu machen, "lesbar" 😉
- Ok, zu konvertieren einen string in ein enum-Konstanten, ist Es wahrscheinlich gut zu werfen eine Ausnahme für den Fall von null oder kein Spiel, das gleiche wie valueOf tut. Jedoch, denken Sie, wie würden Sie implementieren Sie eine Methode, um zu testen, ob ein string verwendet wird, der durch die enum-Konstanten ... Beispiel zu bekommen, um alle, die in stackoverflow.com/a/12659023/744133
- Bezüglich der Fehlerbehandlung, es hängt immer davon ab, Woher die Informationen stammen. Wenn Sie Ihre Werte aus einer externen Quelle stammen (Benutzereingaben,...), über die Sie keine Kontrolle haben, fangen Sie den Fehler und zeigen einige aussagekräftige Meldung aus, wenn möglich. Im Fall, dass der übergebene Wert, um valueOf kommt aus Ihrem eigenen internen code, den Sie fangen sollte, die Fehler und scheitern, hart (log und Absturz) Sie haben wahrscheinlich ein bug ist und er behoben werden kann.
- Ich habe eine wirklich blöde Frage... in deinem fromString Methode direkt nach, wo Sie die equalsIgnoreCase Sie haben b.text. Text ist ein private member der Enumeration-Klasse wie kann man darauf zugreifen?
- Da der code selbst ist in der enum-Klasse und, natürlich, es muss Transparenz über alle Attribute und Methoden der Klasse.
- Ich bevorzuge die null in diesem Fall, denn wenn ich gehen, um den Wert, ich finde es eher pragmatisch zu prüfen if(returnval == null) als die Ausnahme abfangen. Es funktioniert besser, idealistisch zu: macht es mehr Sinn und gibt ein leeres Ergebnis, wenn es nicht mit? oder wirft einen Fehler? Ich denke, es macht mehr Sinn, und gibt ein leeres Ergebnis.
- Ich wollte nicht sagen, dass es falsch ist, hatte ich nicht einmal sagen, dass es schlechte Praxis ist, ich sagte nur, dass das werfen einer Ausnahme sieht mehr angemessen. Überlegen Sie, was der Anrufer zu tun hat: wenn null zurückgegeben wird, dann wird der Rückgabewert geprüft werden nach jedem Anruf, es sei denn, Sie wollen zu fangen NPE, die Sie nicht sollte ;-). Nun schauen Sie, was passiert, wenn eine exception geworfen wird: Der Anrufer kann entscheiden, auf welcher Ebene er will, es zu fangen: Global catch Exception, global catch die Ausnahme im catch die Ausnahme auf einzelnen Anrufe oder eine Kombination davon. Sicherlich viel schöner zu bedienen...
- Um fair zu sein, vor allem, wenn Sie code schreiben, der Letzte und für andere zu verwenden, die entsprechende Sache zu tun, ist etwas, was die Queue Schnittstelle nicht mit remove vs. poll -- zwei Versionen der Methode, gibt null auf (einer sehr vorhersehbaren und Häufig) Fehler, und eine, die eine Ausnahme auslöst, dann lass es, wer benutzt es, zu entscheiden, was zu verwenden, basiert auf, was die größeren Anwendung garantiert.
- Ich denke if (text == null) return null; ist besser als if (text != null) { ....} return null. Der erste Weg ist einfacher zu verstehen.
- "null-sucks" -Doug Lea code.google.com/p/guava-libraries/wiki/...
- text.equalsIgnoreCase(b.text) werfen kann null-Zeiger-Ausnahme aus, wenn null übergeben wird fromString() in der Erwägung, dass b.text.equalsIgnoreCase(text) wird nicht (in Anbetracht der aufgeführten enum-Instanzen).
- bitte, Lesen Sie zwei Zeilen vor, die Sie sagt es ist ein Fehler: if (text != null) {...
- Sorry, schreibt zu schnell... Es ist nicht ein Fehler. Der null-check vermieden werden können. Das ist so, wie "foo".equals(bar) statt bar.equals("foo")
- Könnte auch eine gute Idee, um die Standardeinstellung zu überschreiben toString() auf und stellen es zurück 'text'
- Die Zugabe der text Feld und getText() Methoden ist nicht notwendig, da der code könnte genauso leicht verwendet haben, die automatisch generierte name() Methode. Es ist auch möglich, schreiben Sie eine public static <E extends Enum<E>> com.mylibs.Enums.fromString(E enumType, String s), die funktionieren würde für beliebiger Enum-Typ.
- Eine alternative in vielen Fällen ist eine explizite UNBEKANNTEN Wert für den enum - auf diese Weise können Sie vermeiden, NPEs und noch in der Lage sein zu prüfen, für unbekannte Werte.
- Um fair zu sein, Jon Skeet, die Frage, die er war zu beantworten war die Frage, wie dies zu tun, ohne das werfen und fangen einer Ausnahme. Die Tatsache, dass er die Frage beantwortet, wie gefragt, bedeutet nicht, dass er glaubt, es ist eine gute Idee. @SanghyunLee
- Für was es Wert ist, Kotlin... The valueOf() method throws an IllegalArgumentException if the specified name does not match any of the enum constants defined in the class.
InformationsquelleAutor JoséMi
112

Hier ist ein raffiniertes Dienstprogramm, die ich benutze:
```
/**
 * 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 in meinem enum-Klasse, die ich in der Regel haben diese, um sich Tipparbeit ersparen:
```
public static MyEnum fromString(String name) {
    return getEnumFromString(MyEnum.class, name);
}
```
Wenn Ihr enums sind nicht alle caps, ändern Sie einfach die Enum.valueOf Linie.

Schade, dass ich nicht verwenden können T.class für Enum.valueOf als T gelöscht.
- Die leeren catch-block ist wirklich macht mich verrückt, sorry.
- Ausnahmen sind für außergewöhnliche Bedingungen, die nicht für die Ablaufsteuerung. Holen Sie sich eine Kopie von Effektive Java.
- Wenn die Java-API, die Sie verwenden möchten, wird eine exception geworfen und Sie nicht möchten, dass Ihr code zu werfen, können Sie entweder schlucken die Ausnahme wie diese, oder re-write-Logik von Grund auf, so dass keine Ausnahme geworfen wird, in den ersten Platz. Schlucken die Ausnahme ist oft das kleinere übel.
- Schrecklich! Immer, immer fangen Sie die Ausnahmen, wo man mit Ihnen umgehen kann. Das Beispiel oben ist ein perfektes Beispiel wie man es NICHT machen. Warum? So gibt Sie NULL zurück, und der Anrufer hat dann zu prüfen, gegen NULL oder wirft eine NPE. Wenn der Anrufer weiß, wie man mit der situation umgehen, dann tun einem wenn gegen try-catch kann sehen ein bisschen mehr elegant, ABER, wenn er nicht umgehen kann, er hat übergeben Sie null wieder, und der Anrufer der Anrufer - wieder hat um zu prüfen, gegen NULL usw. etc.
- Um fair zu sein, um die Lösung weiter oben, es gibt wirklich nutzt den Fällen, in denen Sie null zurück, statt dessen wirft IllegalArgumentException und brechen den Fluss von Ihrem Programm, zum Beispiel, mapping Enumerationen, die zwischen einem web-service-schema und ein Datenbank-schema, wobei Sie nicht immer eins-zu-eins. Jedoch, ich bin damit einverstanden, dass der catch-block sollte nie leer sein. Fügen Sie einige code gerne melden.warnen oder zu etwas, das für tracking-Zwecke.
- Absolut! Protokollierung die Ausnahme ist eine sichere Sache. Aber ich Stimme mit schlucken Ausnahmen.
- Jetzt würde ich nur verwenden, Guave ' s Enumerationen. Hinweis die unterschiedliche Behandlung von ungültigen Eingabe: getIfPresent zurück Optional.absent(), das ist, was ich würde es vorziehen, zu verwenden; in der Erwägung, dass valueOfFunction().apply() zurück null.
- Die Probleme, die beginnt, wenn Sie möchten, schreiben Sie eine statische Methode, die prüft, ob eine Zeichenfolge eine enum-Instanz. Der einzige Weg, um zu testen, gegen die verschiedenen enum-Werte ist, um tatsächlich rufen Sie die valueOf-Funktion. Wenn er wirft, das Ergebnis ist falsch.
- Bin ich Etwas fehlt? Was ist der Mehrwert der oben genannten Methoden im Vergleich zu einfach mit: MyEnum.valueOf(name) ?
- Sie sind groß-und Kleinschreibung, im Gegensatz zu valueOf
- Wenn du gehst, um zu schreiben, eine separate routine für groß- / Kleinschreibung-Vergleich, warum dann nicht wirklich mit einem case-insensitive prüfen Sie mit String.equalsIgnoreCase statt diese hardcoded toUpperCase?
- Äquivalent zu apache-common EnumUtils getEnum Methode
- Nein, EnumUtils' getEnum Methode wird nicht mit groß-und Kleinschreibung-lookup.
- Ich mag dieses Dienstprogramm. Wir Hinzugefügt haben, eine "default" - parameter in der Aufzählung nicht ermittelt werden kann: final @Nullable T def
- Eine Seite-Diskussion jetzt aber... eine bessere Praxis ist die Rückgabe Optional, wenn das ist, was von dem, was beabsichtigt war (z.B., vernünftigerweise "unbekannt/nicht definiert"). Dann NPE ist Weg und doch ist die lookup-Fehler nicht wieder eine Ausnahme, als ein Mittel der Ablaufsteuerung.
InformationsquelleAutor Geoffrey Zheng
72

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

Bearbeiten

Geändert toUpperCase zu toUpperCase(Locale.ENGLISH) basierend auf tc. Kommentar und die java docs

edit2
Auf android, die Sie verwenden sollten Gebietsschema.US, als sulai Punkte aus.
- Vorsichtig sein, die Standard-locale!
- Für Sie Android-Nutzer da draußen, ich möchte darauf hinweisen, dass Android-Dokumentation ermutigt ausdrücklich die Verwendung von Locale.US für maschinenlesbare Eingabe/Ausgabe.
- Groß unterschiedlich in den verschiedenen Orten?
- href="http://blog.codinghorror.com/whats-wrong-with-turkey/" >ja.
- Ja, leider. Die Türkei ist ein gutes Beispiel. Kombinieren Sie dies mit Java kaputt ist die Handhabung von Standard-Zeichensätze (Standard: Latin auf Windows anstelle von Unicode) und Sie werden feststellen, es ist fast immer unsicher ist, verwenden Sie die Standard-Versionen der Methoden, die akzeptieren, die eine Zeichensatz-oder Gebietsschema. Sie sollte fast immer explizit definieren.
- Nicht sicher, dass Java "default" - Zeichensätze et al sind "gebrochen" per se, sondern gewährt standardmäßig auf UTF-8 statt der überschreibt (was getan werden sollte immer explizit) gemacht hätte, bessere Systeme für junior Programmierer, die Häufig nicht verstehen, charset Konzepte.
InformationsquelleAutor João Portela
71

Verwenden Sie das Muster von Joshua Bloch, Effektive Java -:

(vereinfacht aus Platzgründen)
```
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 Anzeigen von Instanzen

Die Reihenfolge der Ausführung von statischen Blöcken in einen Enum-Typ

Wie kann ich nachschlagen einer Java-enum aus seinem String-Wert
- wenn Joshua Bloch sagte, es dann dies ist der einzige Weg zu gehen :-). Seine eine Schande, dass ich immer nach unten scrollen müssen hier.
- Dieser ist noch einfacher in Java 8, wie Sie tun können :Stream.of(MyEnum.values()).collect(toMap(Enum::name, identity())) ich auch empfehlen überschreiben von toString() (übergeben durch Konstruktor) und verwenden, die anstelle von Namen, vor allem, wenn die Enum im Zusammenhang mit serialisierbare Daten wie diese können Sie Steuern, das Gehäuse ohne Angabe von Sonar passt.
- Java 8 sicherlich kann/wird sich ändern, viele (bessere) Antworten auf diesem forum. Nicht sicher, jemals den Schwanz (Sonar) wag the dog (application code) obwohl.
- Wenn du gehst, um es in ein unmodifiableMap sowieso, dann gibt es keinen nutzen zu beginnend mit einem ConcurrentHashMap. Verwenden Sie einfach ein HashMap. (Wenn Sie eine Guave ist ImmutableMap dann würde ich empfehlen, dass Sie anstelle!)
- Google ImmutableMap ist sicher der bessere (true tief unveränderlich) die Durchführung aber für den Zweck zu demonstrieren, die nur core-Java-Lösung ... und die Fokussierung auf den String map-lookup Fall, nur core-Java-Klassen verwendet wurden. Im Allgemeinen haben festgestellt, dass ConcurrentHashMap ist fast immer bevorzugt über HashMap angesichts der generellen performance profile (hinzufügen, entfernen, ändern) und der Einfachheit versus Verpackung/sperren HashMap, wenn gleichzeitige änderung berücksichtigt werden.
- Statische Initialisierung ist von Natur aus synchronisiert, es gibt also absolut keinen Grund für die Verwendung ConcurrentHashMap hier, wo die Karte nie geändert werden, werden nach der Initialisierung. Also warum auch z.B. das Beispiel in der JLS selbst verwendet einen regulären HashMap.
- Der Kommentar im code ausdrücklich "alle anzeigen impl tun". Für junior-Entwickler gefunden haben, mit ConcurrentHashMap als eine gängige Praxis vorzuziehen ist im Handel mit gemeinsamen Quellen von bugs in nicht synchronisieren Map-änderungen in der Regel.
- Wenn wir in einer multithreaded Umgebung, dann ist es zwingend, zu denken, über die Konsequenzen unserer Entscheidungen. Defensive Verwendung von synchronized collections, ohne Gedanken gegenläufig zu den Gründen, warum wir eine Parallelität in den ersten Platz. Ich kann nicht sehen, warum eine Sammlung, die in Prinzip sollte eine Unveränderliche Sammlung profitieren können, die durch die Umsetzung als Gleichzeitige Sammlung.
- nochmals wie gesagt, jeder map impl tun und es ist in der Tat keine Konsequenzen, positiv oder negativ für die gegebene impl. Bitte Lesen Sie vor der Bemerkung über die junior-Entwickler so, dass alle Dinge zogen in Betracht, da ConcurrentHashMap hat keine lese-performance penalty hat Anwendbarkeit als universeller Map impl, allgemein über HashMap, wobei die Entwickler müssen denken Sie sehr sorgfältig über die Synchronisierung während der Aktualisierung. So hier, wo ConcurrentHashMap kann verwendet werden, ohne Konsequenz und kann erforderlich sein, in anderen Fällen, wo Synchronisation erforderlich ist - dies scheint durchaus vernünftig.
- Wenn es das ist Ihre Feste überzeugung, dann möchte ich auch beraten über die Verwendung synchronized (map) { ENUM_MAP = Collections.unmodifiableMap(map); } zu vermeiden indeterministic Verhalten in einem möglichen iterator verwendet wird innerhalb der Methode für die Erstellung der unveränderliche version - als standard, so dass der junior-dev nicht zu denken zu viel über die gleichen Folgen. Siehe Synchronisierte Wrapper.
- Danke @YoYo und das ist eine gute impl snippet im Kontext für andere zu verstehen, Auswirkungen der Zugang zu Iteratoren, während die Karten werden aufgebaut/aktualisiert - eine subtile und schwer zu Debuggen Fall.
- sorry, aber ConcurrentHashMap ist völlig nutzlos
InformationsquelleAutor Darrell Teague

Hier ist eine Methode, die es tun können für jede Enum, und ist der groß-und Kleinschreibung.

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

Diese Variante macht es richtig: equalsIgnoreCase ist der Weg zu gehen. +1
Wie Fall insensivity aber ... lieber Enums über (zufällige) String-Zuweisungen für Schlüssel und ... kleiner, aber Durchlaufen ist weniger performant für eine solche möglicherweise repetative-lookup. Daher impl der EnumMap et al.
Dies funktioniert nicht ! Ich habe die equalsIgnoreCase gleich für meine Zwecke. Der code konnte auch wenn beide Eingaben gleich waren genau die gleichen.

InformationsquelleAutor Patrick Arnesen

31

Mit Blah.valueOf(string) ist am besten, aber Sie können Enum.valueOf(Blah.class, string) als gut.
- Groß-und Kleinschreibung, nicht helfen!
- Können Sie das klären, ist Ihr Kommentar? Was versuchen Sie zu tun?
- Hi @PeterLawrey, ich war tring zum abrufen eines Enum aus einem String public enum ObjectType { PERSON("Person") public String parameterName; ObjectType(String parameterName) { dieses.parameterName = parameterName; } public String getParameterName() { return this.parameterName; } public static ObjectType fromString(String parameterName) { if (parameterName != null) { for (ObjectType objType : Objekttyp.values()) { if (parameterName.equalsIgnoreCase(objType.parameterName)) { return objType; } } } return null; } }
InformationsquelleAutor Peter Lawrey
26

Wenn Sie nicht wollen, schreiben Sie Ihre eigenen Dienstprogramm verwenden Sie das Google Guave - Bibliothek:
```
Enums.getIfPresent(Blah.class, "A")
```
Im Gegensatz zu den eingebauten java-Funktion können Sie überprüfen, ob Eine vorhanden ist bla bla Bla und nicht eine Ausnahme werfen.
- traurige Teil ist, dies gibt ein google-Optional und nicht java Optional
- Wahr. Exoected obwohl. Google und Netflix haben große Java-libs. Wo gibt es überschneidungen mit Java catch-up-Klassen implementiert, die in neueren Versionen führt unweigerlich zu ärger. Art von haben zu sein all in nur einem Anbieter, lib.
InformationsquelleAutor Andrejs
22

Meine 2 Cent hier: mit Java8-Streams + überprüfung einer exakten 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));
    }
}
```
** EDIT **

Umbenannt die Funktion fromString() seit der Benennung mit dieser Konvention, Sie erhalten einige Vorteile aus Java-Sprache selbst; zum Beispiel:
1. Direkte Konvertierung von Datentypen unter HeaderParam annotation
- Alternativ, um Ihnen zu erlauben, mehr zu schreiben, lesbar switch - Blöcke, können Sie .orElse(null) statt .orElseThrow() so dass Sie kann code, der die exception werfen in der default - Klausel, sowie weitere nützliche Informationen, wenn erforderlich. Zu machen, und mehr Nachsicht, die Sie nutzen könnten v -> Objects.equals(v.name, s == null ? "" : s.trim().toUpperCase())
- oder einfach nur wieder die Optional aus findFirst(), so dass der Benutzer entscheiden, ob er will .orElse(null), orElseThrow() oder was auch immer....
- Deklarieren einer public static MyEnum valueOf(String) ist eigentlich ein Kompilierungsfehler, da es der gleiche ist wie der implizit definiert, also die ältere version Ihrer Antwort, die eigentlich besser ist. (jls, ideone)
- In meine option ist es besser, zu vermeiden, Ausnahmen und die Nutzung Optional. Neben, wir sollten ungültig, null und verwenden Sie Optional statt als gut.
InformationsquelleAutor Manu

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

InformationsquelleAutor Hans Schreuder

Müssen Sie möglicherweise dieses :

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

Einer Mehr Dazu :

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

Diese werden Sie wieder den Wert von a Stringified Enum-Name Für z.B., wenn Sie "PERSON" in der fromEnumName werde zurückkehren du den Wert des Enum-d.h. "Person"

InformationsquelleAutor Murtaza Kanchwala

11

Einen anderen Weg, dies zu tun durch die Verwendung von impliziten statische Methode name() von Enum. Namen zurück, die die exakte Zeichenkette zu erstellen, die enum, die verwendet werden können, zu überprüfen, vorausgesetzt string:
```
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 von Enum in Java
- Dies ist im wesentlichen, was valueOf für Sie tut. Diese statische Methode nicht bieten nichts extra, ausser et all. Dann die if/else-Konstrukte sind sehr gefährlich ... keine neuen enum-Konstanten Hinzugefügt, wird diese Methode zu brechen, ohne Veränderung.
- Beachten Sie auch das Beispiel dafür, wie wir können valueOf für eine groß-und Kleinschreibung-lookup, oder wie können wir vermeiden, es ist Ausnahme und beschäftigen Aliase, die alternative Namen: stackoverflow.com/a/12659023/744133
- name() ist nicht statisch.
InformationsquelleAutor Vikram

Lösung mit Guava Bibliotheken. Methode getPlanet () ist die groß-und Kleinschreibung, so
getPlanet ("MerCUrY") zurück Planeten.QUECKSILBER.

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

InformationsquelleAutor javabrew

6

Hinzufügen, um die vorherigen Antworten und Adresse einige der Diskussionen rund um Nullen und NPE-ich bin mit Guave Optionen zu behandeln fehlend/ungültig Fällen. Dies funktioniert gut für URI/parameter Parsen.
```
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 nicht bewusst sind, hier sind einige mehr info auf die Vermeidung von null-mit Optional: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

InformationsquelleAutor tom

In Java 8 statische Karte Muster ist noch leichter und ist meine bevorzugte Methode. Wenn Sie möchten, verwenden Sie die Enum mit Jackson können Sie toString überschreiben und verwenden Sie stattdessen den Namen, das dann kommentieren mit @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);
    }
}

InformationsquelleAutor Novaterata

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

werfen Sie einen Blick auf diesen link für Führungen Antworten und Fragen auf stackoverflow.com: stackoverflow.com/faq
Das ist mehr oder weniger das gleiche wie JoséMi Antwort

InformationsquelleAutor Prasobh.Kollattu

O(1) - Methode, inspiriert von Sparsamkeit generierten code mit der Verwendung einer 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;
        }

}

InformationsquelleAutor Sisyphus

3

java.lang.Enum definiert mehrere Methoden, die verfügbar ist, um alle Aufzählungstyp in Java:
- Können Sie name() Methode, um Namen einer Enum-Konstanten. String-literal verwendet, um zu schreiben enum-Konstanten ist Ihr name.
- Ähnlich values() Methode kann verwendet werden, um ein array aller Enum-Konstanten aus der Enum-Typ.
- Und für die gestellte Frage, die Sie verwenden können valueOf() Methode zur Umwandlung von String zu Enum-Konstanten in Java, 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 code-snippet, valueOf() Methode liefert einen Enum-Konstante Geschlecht.MÄNNLICH, ruft Namen auf, die zurück "MALE".

InformationsquelleAutor KNU
3

Apache commons-lang Bibliothek hat eine statische Funktion org.apache.Unterhaus.lang3.EnumUtils.getEnum die Karte eine Zeichenfolge, um Ihre Enum-Typ. Gleiche Antwort im wesentlichen als Geoffreys aber warum Rollen Sie Ihre eigenen, wenn es dort draußen in der wildnis schon.

InformationsquelleAutor pjklauser
3

Hinzufügen zu den top bewerteten Antwort, eine hilfreiche utility...

valueOf() wirft zwei verschiedenen Ausnahmen in Fällen, wo es nicht wie die Eingabe.
- IllegalArgumentException
- NullPointerExeption
Wenn Ihre Anforderungen sind, so dass Sie don ' T haben keine Garantie, dass Ihr String wird auf jeden Fall mit einer enum-Wert, zum Beispiel, wenn die Zeichenfolge von Daten aus einer Datenbank kommt und könnte enthalten alte version des enum ist, dann benötigen Sie für die Handhabung dieser oft...

So, hier ist eine wiederverwendbare Methode, die ich schrieb, was uns ermöglicht, definieren Sie einen Standard-Enum werden zurückgegeben, wenn der String übergeben wir nicht übereinstimmen.
```
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 wie diese:
```
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
}
```
InformationsquelleAutor lance.dolan

Was?

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

InformationsquelleAutor DCO

Einem anderen Programm erfassen in umgekehrter Weise. Mit einem Wert erkennen, dass Enum nicht von seinem Namen.

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") zurück Foo.THREE, da wird es mit getValue zu entsprechen, "drei", das ist einzigartig öffentlichkeit, nicht endgültig und nicht statische Methode Foo.
Im Fall Foo hat mehr als auf öffentlichen, nicht endgültig und nicht statische Methode, zum Beispiel getTranslate gibt "drei", die andere Methode, die verwendet werden können: EnumUtil.from(Foo.class, "drei", "getTranslate").

InformationsquelleAutor Moesio

Als switch-version noch nicht angesprochen wurde-ich Stelle Sie (die Wiederverwendung von OP ' s enum):

  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 diese keine zusätzlichen Wert für das valueOf(String name) Methode, es macht nur Sinn, definieren Sie eine zusätzliche Methode, wenn wir wollen, haben ein anderes Verhalten. Wenn wir nicht wollen, um eine IllegalArgumentException wir können ändern Sie die Implementierung an:

  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 Bereitstellung einer default-Wert wir halten die Vertrag von Enum.valueOf(String name) ohne auslösen einer IllegalArgumentException auf diese Weise, dass in keinem Fall null zurückgegeben. Daher werfen wir einen NullPointerException wenn der name null - und im Fall der default wenn defaultValue ist null. Das ist, wie valueOfOrDefault funktioniert.

Dieser Ansatz nimmt das design der Map-Schnittstelle bietet eine Methode Map.getOrDefault(Object key, V defaultValue) ab Java 8.

InformationsquelleAutor LuCio

Enum ist sehr nützlich, ich habe mit Enum eine Menge, um eine Beschreibung hinzuzufügen für einige Felder in verschiedenen Sprachen, 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;
    }
}

Dann können Sie den Abruf dynamisch mit Sitz in der language-code übergeben getDescription(String lang) Methode, zum Beispiel:

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

InformationsquelleAutor Ebraheem Alrabee'

Ich mag diese Art von Prozess zu analysieren Befehle als strings in Aufzählungen. Normalerweise habe ich eine der Enumerationen als "unbekannt", so dass es hilft, die zurückgegeben werden, wenn der andere nicht zu finden sind (auch auf groß-und Kleinschreibung-basis) anstatt null (dass es also keinen Wert). Daher habe ich diesen Ansatz verwenden.

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

Sieht gut aus, aber im wesentlichen die gleichen wie Patrick Arnesen ' s Antwort...

InformationsquelleAutor John Hemming

Schnellste Weg, um den Namen der enum ist, eine map zu erstellen enum text und Wert, wenn Sie die Anwendung starten, und, um den Namen rufen Sie die Funktion bla bla Bla.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.toString());
        }
    }
    public static String getEnumName(String text) {
        return map.get(text.toLowerCase());
    } 
}

InformationsquelleAutor Bishal Jaiswal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.