Convert from String to a Java enum with large amount of values [duplicate]

Question

Let's say I have an enum with 100 values. For simplicity's sake, take the following example:

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

I want to create a public method to convert strings with a known format (like "string1", "string2"...) to the appropiate enum value CODE_1, CODE_2... Typically this is done by iterating over all values, and if a match is found, return that enum value. (Details can be found in this question.)

However, I'm concerned with reguraly looping over all values. Could this potentially be a huge bottleneck? What if instead of 100 element, there were 1000?

As an exercise for myself, I tried to optimize this lookup with a static map, which can assure O(1) lookup time given any string. I like this extra gimmick, but I only want to include it in my code if it is actually necessary. What are your thoughts and findings on using the iterating method vs the map method?

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

Answer 1

You want a Map<String, Code>, but how to populate it neatly? Enums don't allow you to initialize a static fields before the enum instances are initialized, but there's a neat little trick, called the Initialization-on-demand holder idiom, that makes using a statically initialized map needed for this functionality easy to implement:

public enum Code {     CODE_1("string1"),     CODE_2("string2"),     CODE_3("string3"),     // etc     ;      private static class Holder {         static Map<String, Code> CODE_MAP = new HashMap<>();     }      private final String code;      private Code(String code) {         this.code = code;         Holder.CODE_MAP.put(code, this);     }      public String getCode() {         return this.code;     }      public Code convertFromString(String code) {         return Holder.CODE_MAP.get(code);     } } 

This works because the class loader initializes inner static classes before initializing the enum class, so the map is assigned ready to load during enum instance initialization.

No loops. No special code to load the map (done in constructor). Minimal code.

Answer 2

Map is good option : cleaner code and O(1) . If you use for-loop then the best you get is O(n)