¿Cómo puedo buscar una enumeración de Java a partir de su valor de cadena?

Me gustaría buscar una enumeración de su valor de cadena (o posiblemente cualquier otro valor). He intentado el siguiente código pero no permite la estática en los inicializadores. ¿Hay una manera simple?

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 el valueOfmétodo que se crea automáticamente para cada Enum.

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

Para valores arbitrarios comience con:

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

Avanza más tarde a la implementación del mapa si tu generador de perfiles te lo indica.

Sé que está iterando sobre todos los valores, pero con solo 3 valores de enumeración no vale la pena ningún otro esfuerzo, de hecho, a menos que tenga muchos valores, no me molestaría con un Mapa, será lo suficientemente rápido.

Estás cerca. Para valores arbitrarios, intente algo como lo siguiente:

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 puedes lograr de esta manera:

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

La respuesta de @ Lyle es bastante peligrosa y he visto que no funciona particularmente si hace que la enumeración sea una clase interna estática. En cambio, he usado algo como esto que cargará los mapas BootstrapSingleton antes de las enumeraciones.

Editar esto ya no debería ser un problema con las JVM modernas (JVM 1.6 o superior), pero creo que todavía hay problemas con JRebel, pero no he tenido la oportunidad de volver a probarlo .

Cargame primero:

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

Ahora cárguelo en el constructor 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);
        }
    }

Si tiene una enumeración interna, puede definir el Mapa sobre la definición de enumeración y eso (en teoría) debería cargarse antes.

¿Y no puedes usar valueOf () ?

Editar: Por cierto, no hay nada que te impida usar static {} en una enumeración.

En caso de que ayude a otros, la opción que prefiero, que no se encuentra aquí, utiliza la funcionalidad de Mapas de 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 el valor predeterminado que puede usar null, puede throw IllegalArgumentExceptiono fromStringpuede devolver un Optionalcomportamiento que prefiera.

desde java 8 puede inicializar el mapa en una sola línea y sin bloque estático

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

Quizás, eche un vistazo a esto. Me está funcionando. El propósito de esto es buscar 'RED' con '/ red_color'. Declarar ay static mapcargar los enums solo una vez traerá algunos beneficios de rendimiento si los enums son muchos.

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, ponga sus opiniones.

Puede definir su Enum como el siguiente 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();
   }
};

Consulte el siguiente enlace para obtener más aclaraciones.

Si desea un valor predeterminado y no desea crear mapas de búsqueda, puede crear un método estático para manejarlo. Este ejemplo también maneja búsquedas donde el nombre esperado comenzaría con un 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;
        }
    }

Si lo necesita en un valor secundario, simplemente construirá el mapa de búsqueda primero como en algunas de las otras respuestas.

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

}

Puede usar la Enum::valueOf()función sugerida por Gareth Davis y Brad Mace arriba, pero asegúrese de manejar la IllegalArgumentExceptionque se lanzaría si la cadena utilizada no está presente en la enumeración.