Esta pergunta já tem uma resposta aqui:

Digamos que eu tenho um enum com 100 valores. Por uma questão de simplicidade, veja o seguinte exemplo:

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

Desejo criar um método público para converter seqüências de caracteres com um formato conhecido (como "string1", "string2" ...) no valor de enum apropriado CODE_1, CODE_2 ... Normalmente, isso é feito através da iteração sobre todos os valores e, se for encontrada uma correspondência, retorne esse valor de enumeração. (Detalhes podem ser encontradosnesta pergunta.)

No entanto, estou preocupado com a repetição regular de todos os valores. Isso poderia ser um gargalo enorme? E se, em vez de 100 elementos, houvesse 1000?

Como exercício para mim, tentei otimizar essa pesquisa com um mapa estático, o que pode garantir o tempo de pesquisa O (1), dada qualquer string. Gosto desse truque extra, mas só quero incluí-lo no meu código se for realmente necessário. Quais são seus pensamentos e descobertas sobre o uso do método de iteração versus o método de 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);
    }
}