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

Ich möchte eine Aufzählung anhand ihres Zeichenfolgenwerts (oder möglicherweise eines anderen Werts) nachschlagen. Ich habe den folgenden Code ausprobiert, aber er erlaubt keine statische Aufladung in Initialisierern. Gibt es einen einfachen Weg?

public enum Verbosity {

    BRIEF, NORMAL, FULL;

    private static Map<String, Verbosity> stringMap = new HashMap<String, Verbosity>();

    private Verbosity() {
        stringMap.put(this.toString(), this);
    }

    public static Verbosity getVerbosity(String key) {
        return stringMap.get(key);
    }
};

Verwenden Sie die valueOfMethode, die automatisch für jede Aufzählung erstellt wird.

Verbosity.valueOf("BRIEF") == Verbosity.BRIEF

Für beliebige Werte beginnen Sie mit:

public static Verbosity findByAbbr(String abbr){
    for(Verbosity v : values()){
        if( v.abbr().equals(abbr)){
            return v;
        }
    }
    return null;
}

Fahren Sie erst später mit der Map-Implementierung fort, wenn Sie von Ihrem Profiler dazu aufgefordert werden.

Ich weiß, dass es über alle Werte iteriert, aber mit nur 3 Aufzählungswerten ist es kaum eine andere Anstrengung wert. Wenn Sie nicht viele Werte haben, würde ich mich nicht um eine Karte kümmern, wird es schnell genug sein.

Du bist nah dran. Versuchen Sie für beliebige Werte Folgendes:

public enum Day { 

    MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"),
    THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ;

    private final String abbreviation;

    // Reverse-lookup map for getting a day from an abbreviation
    private static final Map<String, Day> lookup = new HashMap<String, Day>();

    static {
        for (Day d : Day.values()) {
            lookup.put(d.getAbbreviation(), d);
        }
    }

    private Day(String abbreviation) {
        this.abbreviation = abbreviation;
    }

    public String getAbbreviation() {
        return abbreviation;
    }

    public static Day get(String abbreviation) {
        return lookup.get(abbreviation);
    }
}

Mit Java 8 können Sie Folgendes erreichen:

public static Verbosity findByAbbr(final String abbr){
    return Arrays.stream(values()).filter(value -> value.abbr().equals(abbr)).findFirst().orElse(null);
}

@ Lyles Antwort ist ziemlich gefährlich und ich habe gesehen, dass es nicht besonders funktioniert, wenn Sie die Aufzählung zu einer statischen inneren Klasse machen. Stattdessen habe ich so etwas verwendet, das die BootstrapSingleton-Maps vor den Aufzählungen lädt.

Bearbeiten Dies sollte mit modernen JVMs (JVM 1.6 oder höher) kein Problem mehr sein, aber ich denke, es gibt immer noch Probleme mit JRebel, aber ich hatte keine Chance, es erneut zu testen .

Lade mich zuerst:

   public final class BootstrapSingleton {

        // Reverse-lookup map for getting a day from an abbreviation
        public static final Map<String, Day> lookup = new HashMap<String, Day>();
   }

Laden Sie es nun in den Enum-Konstruktor:

   public enum Day { 
        MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"),
        THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ;

        private final String abbreviation;

        private Day(String abbreviation) {
            this.abbreviation = abbreviation;
            BootstrapSingleton.lookup.put(abbreviation, this);
        }

        public String getAbbreviation() {
            return abbreviation;
        }

        public static Day get(String abbreviation) {
            return lookup.get(abbreviation);
        }
    }

Wenn Sie eine innere Aufzählung haben, können Sie einfach die Karte über der Aufzählungsdefinition definieren und diese sollte (theoretisch) vorher geladen werden.

Und Sie können valueOf () nicht verwenden ?

Bearbeiten: Übrigens hindert Sie nichts daran, statisches {} in einer Aufzählung zu verwenden.

Falls es anderen hilft, verwendet die von mir bevorzugte Option, die hier nicht aufgeführt ist, die Kartenfunktion von Guava :

public enum Vebosity {
    BRIEF("BRIEF"),
    NORMAL("NORMAL"),
    FULL("FULL");

    private String value;
    private Verbosity(final String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }

    private static ImmutableMap<String, Verbosity> reverseLookup = 
            Maps.uniqueIndex(Arrays.asList(Verbosity.values()), Verbosity::getValue);

    public static Verbosity fromString(final String id) {
        return reverseLookup.getOrDefault(id, NORMAL);
    }
}

Mit der Standardeinstellung, die Sie verwenden können null, können throw IllegalArgumentExceptionoder können Sie fromStringein Optionalbeliebiges Verhalten zurückgeben.

Seit Java 8 können Sie die Karte in einer einzigen Zeile und ohne statischen Block initialisieren

private static Map<String, Verbosity> stringMap = Arrays.stream(values())
                 .collect(Collectors.toMap(Enum::toString, Function.identity()));

Vielleicht werfen Sie einen Blick darauf. Es funktioniert für mich. Der Zweck ist, 'RED' mit '/ red_color' nachzuschlagen. Das Deklarieren von a static mapund das enumeinmalige Laden des s würde einige Leistungsvorteile bringen, wenn enumes viele s gibt.

public class Mapper {

public enum Maps {

    COLOR_RED("/red_color", "RED");

    private final String code;
    private final String description;
    private static Map<String, String> mMap;

    private Maps(String code, String description) {
        this.code = code;
        this.description = description;
    }

    public String getCode() {
        return name();
    }

    public String getDescription() {
        return description;
    }

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

    public static String getColorName(String uri) {
        if (mMap == null) {
            initializeMapping();
        }
        if (mMap.containsKey(uri)) {
            return mMap.get(uri);
        }
        return null;
    }

    private static void initializeMapping() {
        mMap = new HashMap<String, String>();
        for (Maps s : Maps.values()) {
            mMap.put(s.code, s.description);
        }
    }
}
}

Bitte geben Sie Ihre Meinung ein.

Sie können Ihre Aufzählung wie folgt definieren:

public enum Verbosity 
{
   BRIEF, NORMAL, FULL, ACTION_NOT_VALID;
   private int value;

   public int getValue()
   {
     return this.value;
   } 

   public static final Verbosity getVerbosityByValue(int value)
   {
     for(Verbosity verbosity : Verbosity.values())
     {
        if(verbosity.getValue() == value)
            return verbosity ;
     }

     return ACTION_NOT_VALID;
   }

   @Override
   public String toString()
   {
      return ((Integer)this.getValue()).toString();
   }
};

Weitere Informationen finden Sie unter folgendem Link

Wenn Sie einen Standardwert möchten und keine Lookup-Maps erstellen möchten, können Sie eine statische Methode erstellen, um dies zu handhaben. In diesem Beispiel werden auch Suchvorgänge behandelt, bei denen der erwartete Name mit einer Zahl beginnen würde.

    public static final Verbosity lookup(String name) {
        return lookup(name, null);
    }

    public static final Verbosity lookup(String name, Verbosity dflt) {
        if (StringUtils.isBlank(name)) {
            return dflt;
        }
        if (name.matches("^\\d.*")) {
            name = "_"+name;
        }
        try {
            return Verbosity.valueOf(name);
        } catch (IllegalArgumentException e) {
            return dflt;
        }
    }

Wenn Sie es für einen sekundären Wert benötigen, erstellen Sie zuerst die Lookup-Map wie in einigen anderen Antworten.

public enum EnumRole {

ROLE_ANONYMOUS_USER_ROLE ("anonymous user role"),
ROLE_INTERNAL ("internal role");

private String roleName;

public String getRoleName() {
    return roleName;
}

EnumRole(String roleName) {
    this.roleName = roleName;
}

public static final EnumRole getByValue(String value){
    return Arrays.stream(EnumRole.values()).filter(enumRole -> enumRole.roleName.equals(value)).findFirst().orElse(ROLE_ANONYMOUS_USER_ROLE);
}

public static void main(String[] args) {
    System.out.println(getByValue("internal role").roleName);
}

}}

Sie können die Enum::valueOf()von Gareth Davis & Brad Mace oben vorgeschlagene Funktion verwenden, aber stellen Sie sicher, dass Sie mit der Funktion umgehen IllegalArgumentException, die ausgelöst wird, wenn die verwendete Zeichenfolge nicht in der Aufzählung vorhanden ist.