Como posso procurar uma enumeração Java a partir do seu valor String?

Eu gostaria de procurar uma enumeração a partir do seu valor de string (ou possivelmente qualquer outro valor). Eu tentei o código a seguir, mas ele não permite estática nos inicializadores. Existe uma maneira simples?

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

Use o valueOfmétodo criado automaticamente para cada Enum.

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

Para valores arbitrários, comece com:

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

Avance apenas mais tarde para a implementação do Mapa se o seu profiler solicitar.

Eu sei que ele está iterando sobre todos os valores, mas com apenas 3 valores enum dificilmente vale a pena qualquer outro esforço, na verdade, a menos que você tenha muitos valores, eu não me incomodaria com um mapa, será rápido o suficiente.

Você está perto. Para valores arbitrários, tente algo como o seguinte:

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

com o Java 8, você pode conseguir desta maneira:

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

@ A resposta de Lyle é bastante perigosa e vi que não funcionará particularmente se você fizer do enum uma classe interna estática. Em vez disso, usei algo assim, que carregará os mapas BootstrapSingleton antes das enumerações.

Editar isso não deve mais ser um problema com as JVMs modernas (JVM 1.6 ou superior), mas acho que ainda existem problemas com o JRebel, mas não tive a chance de testá-lo novamente .

Carregue-me primeiro:

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

Agora carregue-o no construtor 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 você tem uma enumeração interna, basta definir o Mapa acima da definição de enumeração e que (em teoria) deve ser carregado antes.

E você não pode usar valueOf () ?

Edit: Btw, não há nada impedindo você de usar static {} em uma enumeração.

Caso ajude outras pessoas, a opção que eu prefiro, que não está listada aqui, usa a funcionalidade Mapas do 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);
    }
}

Com o padrão que você pode usar null, você pode throw IllegalArgumentExceptionou fromStringpode retornar um Optional, qualquer que seja o comportamento de sua preferência.

desde o java 8 você pode inicializar o mapa em uma única linha e sem bloco estático

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

Talvez, dê uma olhada nisso. Está funcionando para mim. O objetivo disso é pesquisar 'RED' com '/ red_color'. Declarar ae static mapcarregar os enums somente uma vez traria alguns benefícios de desempenho se os enums fossem muitos.

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

Por favor, coloque suas opiniões.

Você pode definir seu Enum como o seguinte código:

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

Veja o link a seguir para mais esclarecimentos

Se você deseja um valor padrão e não deseja criar mapas de pesquisa, pode criar um método estático para lidar com isso. Este exemplo também lida com pesquisas onde o nome esperado começaria com um número.

    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 você precisar dele com um valor secundário, basta criar o mapa de pesquisa primeiro, como em algumas das outras respostas.

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

}

Você pode usar a Enum::valueOf()função conforme sugerido por Gareth Davis e Brad Mace acima, mas lembre-se de lidar com o IllegalArgumentExceptionque seria lançado se a string usada não estiver presente na enumeração.