Come posso cercare un enum Java dal suo valore String?

Vorrei cercare un enum dal suo valore di stringa (o possibilmente qualsiasi altro valore). Ho provato il seguente codice ma non consente statici negli inizializzatori. C'è un modo semplice?

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

Utilizzare il valueOfmetodo che viene creato automaticamente per ogni Enum.

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

Per valori arbitrari iniziare con:

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

Passa successivamente all'implementazione della Mappa solo se il tuo profiler te lo dice.

So che sta iterando su tutti i valori, ma con solo 3 valori enum non vale quasi nessun altro sforzo, infatti a meno che tu non abbia molti valori non mi preoccuperei di una mappa, sarà abbastanza veloce.

Sei vicino Per valori arbitrari, prova qualcosa di simile al seguente:

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

con Java 8 puoi ottenere in questo modo:

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

La risposta di Lyle è piuttosto pericolosa e ho visto che non funziona in modo particolare se fai dell'enum una classe interna statica. Invece ho usato qualcosa del genere che caricherà le mappe BootstrapSingleton prima degli enum.

Modifica questo non dovrebbe più essere un problema con le moderne JVM (JVM 1.6 o successive) ma penso che ci siano ancora problemi con JRebel ma non ho avuto la possibilità di testarlo nuovamente .

Prima caricami:

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

Ora caricalo nel costruttore enum:

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

Se hai un enum interno puoi semplicemente definire la mappa sopra la definizione di enum e che (in teoria) dovrebbe essere caricata prima.

E non puoi usare valueOf () ?

Modifica: A proposito, non c'è nulla che ti impedisca di usare static {} in un enum.

Nel caso in cui aiuti gli altri, l'opzione che preferisco, che non è elencata qui, utilizza la funzionalità Mappe di 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);
    }
}

Con il valore predefinito che puoi utilizzare null, puoi throw IllegalArgumentExceptiono fromStringpotresti restituire un Optionalcomportamento qualunque tu preferisca.

da java 8 è possibile inizializzare la mappa in una sola riga e senza blocco statico

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

Forse, dai un'occhiata a questo. Funziona per me. Lo scopo è cercare 'ROSSO' con '/ rosso_colore'. Dichiarare una static mape caricare le enums una sola volta porterebbe alcuni vantaggi in termini di prestazioni se le enums sono molte.

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

Per favore, inserisci le tue opinioni.

Puoi definire il tuo Enum come il seguente codice:

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

Vedi il link seguente per ulteriori chiarimenti

Se si desidera un valore predefinito e non si desidera creare mappe di ricerca, è possibile creare un metodo statico per gestirlo. Questo esempio gestisce anche le ricerche in cui il nome previsto inizierà con un numero.

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

Se ne hai bisogno su un valore secondario, costruiresti prima la mappa di ricerca come in alcune delle altre risposte.

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

}

Puoi usare la Enum::valueOf()funzione come suggerito da Gareth Davis e Brad Mace sopra, ma assicurati di gestire IllegalArgumentExceptionciò che verrebbe lanciato se la stringa usata non fosse presente nell'enum.