Esta pregunta ya tiene una respuesta aquí:

Digamos que tengo una enumeración con 100 valores. Por simplicidad, tome el siguiente ejemplo:

public enum code
{
    CODE_1("string1"),
    CODE_2("string2"),
    CODE_3("string3"),
    CODE_4("string4"),
    ...
}

Quiero crear un método público para convertir cadenas con un formato conocido (como "cadena1", "cadena2" ...) al valor de enumeración apropiado CODE_1, CODE_2 ... Normalmente, esto se hace iterando sobre todos los valores, y si se encuentra una coincidencia, devuelve ese valor de enumeración. (Se pueden encontrar detallesen esta pregunta.)

Sin embargo, me preocupa el bucle de todos los valores. ¿Podría ser esto potencialmente un gran cuello de botella? ¿Qué pasa si en lugar de 100 elementos, hay 1000?

Como ejercicio para mí, traté de optimizar esta búsqueda con un mapa estático, que puede asegurar el tiempo de búsqueda O (1) dada cualquier cadena. Me gusta este truco extra, pero solo quiero incluirlo en mi código si es realmente necesario. ¿Cuáles son sus pensamientos y hallazgos sobre el uso del método iterativo frente al método del mapa?

public enum Code
{
    ...
    //enum values
    ...


    //The string-to-Code map
    private static final Map<String,Code> CODE_MAP = populateMap();

    private static Map<String,Code> populateMap()
    {
        Map<String,Code> map = new HashMap<String,Code>();

        for(Code c : Code.values())
        {
            map.put(c.getCode(), c);
        }

        return map;
    }


    private String code;

    private Code(String code)
    {
        this.code = code;
    }

    public String getCode()
    {
        return this.code;
    }

    public Code convertFromString(String code)
    {
        //assume that the given string is actually a key value in the map

        return (Code) CODE_MAP.get(code);
    }
}