The proper way to look up an enum by value

I have several Java enums that looks something like below (edited for confidentiality, etc). In each case, I have a lookup method that I'm really not satisfied with; in the example below, it is findByChannelCode.

public enum PresentationChannel {
    ChannelA("A"),
    ChannelB("B"),
    ChannelC("C"),
    ChannelD("D"),
    ChannelE("E");

    private String channelCode;

    PresentationChannel(String channelCode) {
        this.channelCode = channelCode;
    }

    public String getChannelCode() {
        return this.channelCode;
    }

    public PresentationChannel findByChannelCode(String channelCode) {
        if (channelCode != null) {
            for (PresentationChannel presentationChannel : PresentationChannel.values()) {
                if (channelCode.equals(presentationChannel.getChannelCode())) {
                    return presentationChannel;
                }
            }
        }

        return null;
    }
}

The problem is, I feel silly doing these linear lookups when I could just be using a HashMap<String, PresentationChannel>. So I thought of the solution below, but it's a little messier that I would hope and, more to the point, I didn't care to re-invent the wheel when surely someone else has come across this. I wanted to get some of the sage wisdom of this group: what is the proper way to index an enum by value?

My solution:

ImmutableMap<String, PresentationChannel> enumMap = Maps.uniqueIndex(ImmutableList.copyOf(PresentationChannel.values()), new Function<PresentationChannel, String>() {
        public String apply(PresentationChannel input) {
            return input.开发者_如何学PythongetChannelCode();
        }});

and, in the enum:

public static PresentationChannel findByChannelCode(String channelCode) {
     return enumMap.get(channelCode);
}

I think you're using non-JDK classes here right?

A similar solution with JDK API:

private static final Map<String, PresentationChannel> channels = new HashMap<String, PresentationChannel>();

static{
  for (PresentationChannel channel : values()){
    channels.put(channel.getChannelCode(), channel);
  }
}

I wanted to get some of the sage wisdom of this group: what is the proper way to index an enum by value?

Quite possibly not doing it at all.

While hash tables provide O(1) lookup, they also have quite a large constant overhead (for hash calculations etc), so for small collections a linear search may well be faster (if "the efficient way" is your definition of "the proper way").

If you just want a DRY way to do it, I suppose Guava's Iterables.find is an alternative:

return channelCode == null ? null : Iterables.find(Arrays.asList(values()),
    new Predicate<PresentationChannel>() {
        public boolean apply(PresentationChannel input) {
            return input.getChannelCode().equals(channelCode);
        }
    }, null);

Why don't you name your members A, B, C, D, E and use valueOf?

I was looking for something similar and found on this site a simple, clean and straight to the point way. Create and initialize a static final map inside your enum and add a static method for the lookup, so it would be something like:

public enum PresentationChannel {
    ChannelA("A"),
    ChannelB("B"),
    ChannelC("C"),
    ChannelD("D"),
    ChannelE("E");

    private String channelCode;

    PresentationChannel(String channelCode) {
        this.channelCode = channelCode;
    }

    public String getChannelCode() {
        return this.channelCode;
    }

    private static final Map<String, PresentationChannel> lookup 
            = new HashMap<String, PresentationChannel>();

    static {
        for(PresentationChannel pc : EnumSet.allOf(PresentationChannel.class)) {
            lookup.put(pc.getChannelCode(), pc);
        }
    }

    public static PresentationChannel get(String channelCode) { 
        return lookup.get(channelCode); 
    }
}

for few values that's ok, iteration through the values array(). One note only: use smth like that. values() clones the array on each invocation.

static final PresentationChannel[]  values=values(); 
static PresentationChannel getByCode(String code){
  if (code==null)
    return null;
  for(PresentationChannel channel: values) if (code.equals(channel.channelCode)) return channel;
  return null;
}

if you have more Channels.

private static final Map<String code, PresentationChannel> map = new HashMap<String code, PresentationChannel>();
static{//hashmap sucks a bit, esp if you have some collisions so you might need to initialize the hashmap depending on the values count and w/ some arbitrary load factor
  for(PresentationChannel channel: values())  map.put(channel.channelCode, channel);
}

static PresentationChannel getByCode(String code){
  return map.get(code);
}

Edit:

So implement an helper interface, like shown below, another example why java syntax generics blows and sometimes - better not used.

Usage PresentationChannel channel = EnumRepository.get(PresentationChannel.class, "A");
There will be overhead but well, it's quite fool proof.

public interface Identifiable<T> {  
      T getId();    



    public static class EnumRepository{
      private static final ConcurrentMap<Class<? extends Identifiable<?>>, Map<?, ? extends Identifiable<?>>> classMap = new ConcurrentHashMap<Class<? extends Identifiable<?>>, Map<?,? extends Identifiable<?>>>(16, 0.75f, 1);

      @SuppressWarnings("unchecked")
      public static <ID, E extends Identifiable<ID>> E get(Class<E> clazz, ID value){
        Map<ID, E> map = (Map<ID, E>) classMap.get(clazz);
        if (map==null){
            map=buildMap(clazz);
            classMap.putIfAbsent(clazz, map);           
        }
        return map.get(value);
      }

      private static <ID, E extends Identifiable<ID>> Map<ID, E> buildMap( Class<E> clazz){
        E[] enumConsts = clazz.getEnumConstants();
        if (enumConsts==null)
            throw new IllegalArgumentException(clazz+ " is not enum");

        HashMap<ID, E> map = new HashMap<ID, E>(enumConsts.length*2);
        for (E e : enumConsts){
            map.put(e.getId(), e);
        }
        return map;
      }      
    }
}

enum X implements Identifiable<String>{
...
public String getId(){...}
}

Minor warning: if you put Identifiable somewhere out there, and many projects/wepapp depend on it (and share it) and so on, it's possible to leak classes/classloaders.

Here is another way to implement an unmodifiable map:

protected static final Map<String, ChannelCode> EnumMap;
static { 
    Map<String, ChannelCode> tempMap = new HashMap<String, ChannelCode>();
    tempMap.put("A", ChannelA);
    tempMap.put("B", ChannelB);
    tempMap.put("C", ChannelC);
    tempMap.put("D", ChannelD);
    tempMap.put("E", ChannelE);
    EnumMap = Collections.unmodifiableMap(tempMap);
}

You can use EnumMap.get(someCodeAthroughE) to quickly retrieve the ChannelCode. If the expression is null then your someCodeAthroughE was not found.

If you are expecting the provided channelCode to always be valid then you can just try and get the correct instance of the enum using the valueOf() method. If the provided value is invalid you can return null or propagate the exception.

try {
    return PresentationChannel.valueOf(channelCode);
catch (IllegalArgumentException e) {
    //do something.
}