Frage Suchen Sie Java-Enumeration nach Zeichenfolgenwert


Sag, ich habe ein enum, das gerecht ist

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

und ich möchte zum Beispiel den Enum-Wert einer Zeichenkette finden "A" welches sein würde Blah.A. Wie wäre es möglich, dies zu tun?

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


1590
2018-03-02 22:56


Ursprung


Antworten:


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

Beachten Sie, dass der Name ein sein muss genau Übereinstimmung, einschließlich Fall: Blah.valueOf("a") und Blah.valueOf("A ") beide werfen ein IllegalArgumentException.

Die statischen Methoden valueOf() und values() werden zur Kompilierzeit erstellt und erscheinen nicht im Quellcode. Sie erscheinen jedoch in Javadoc; beispielsweise, Dialog.ModalityType zeigt beide Methoden an.


1851
2018-03-02 22:57



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

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

709
2018-06-03 10:57



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

In meiner Enum-Klasse habe ich das normalerweise, um ein wenig Tipparbeit zu sparen:

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

Wenn Ihre Enums keine Großbuchstaben sind, ändern Sie einfach die Enum.valueOf Linie.

Schade, dass ich nicht benutzen kann T.class zum Enum.valueOf wie T ist gelöscht.


98
2017-11-12 15:52



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

bearbeiten
Geändert toUpperCase zu toUpperCase(Locale.ENGLISH) beyogen auf tc. Kommentar und das Java-Dokumente

edit2 Auf Android sollten Sie verwenden Locale.US, wie Sulai weist darauf hin.


66
2018-05-09 16:33



Benutze das Muster von Joshua Bloch, Wirksames Java:

(vereinfacht für die Kürze)

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 der statischen Blöcke in einem Enum-Typ

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


37
2018-06-15 16:37



Hier ist eine Methode, die es für jede Enum machen kann, und die Groß- und Kleinschreibung nicht beachtet.

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

35
2017-12-01 21:53



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


28
2018-05-09 17:23



Wenn Sie kein eigenes Dienstprogramm schreiben möchten, verwenden Sie Google  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öst.


22
2018-04-02 20:12



Möglicherweise müssen Sie Folgendes tun:

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

Eine weitere 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 Stringed Enum Name für z. Wenn Sie "PERSON" im fromEnumName angeben, erhalten Sie den Wert der Enum, d. h. "Person"


13
2017-07-02 11:54



Eine andere Möglichkeit, dies mit der impliziten statischen Methode zu tun name() von Enum. name gibt die exakte Zeichenkette zurück, mit der diese Enumeration erstellt wurde, die verwendet werden kann, um die angegebene Zeichenfolge zu überprüfen:

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


11
2017-11-29 05:02



In Java 8 oder später unter Verwendung von 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 Blah fromText(String text) {
        return Arrays.stream(values())
          .filter(bl -> bl.text.equalsIgnoreCase(text))
          .findFirst()
          .orElse(null);
    }
}

10
2017-08-01 10:17