dev/java tips/enum reverse lookup 1 reverse lookup with enums The implementation of enumerations is great in java. In this Post I will introduce a very helpful hint for reverse lookup of enums. 1.1 What is reverse lookup Just consider the case that there are some non easy understandable status columns within the database. In the java application it is wise to have enums with comprehensive items, so the code is understood very easy. For example just the gender column for user is in some databases realized as a varchar(1) or char column with 'M' for male and 'F' for female. (Don't blame me for this database definitions. I came across many of this kind definitions and in a ideal world you would define lookup table in the database and link the value to them. But this is just an example for the use case :) ) So in the first place the enum for gender could look like this: {code:type=java} public enum Gender { MALE, FEMALE; } {code} One would then use switch-case-instructions (actually I have seen this on the time of writing many times) to assign the database value and to get the enum from the database. But the most elegant way is to use the abilities of enums itself. Enums are in java classes by itself and may have constructors, members and functions. So let's use them. {code:type=java} public enum Gender { MALE("M"), FEMALE("F"); protected String dbValue; public Gender(String s) { dbValue=s; } public String getDbValue() { return dbValue;} // prepare for reverse lookup public static Map<String, Gender> lookupMap = new HashMap<String, Gender>(); // fill the reverse lookup map, alternatively this could be done within the constructor. static { for(Gender item : EnumSet.allOf(Gender.class)) lookupMap.put(item.getDbValue(), item); } public Gender findbyDbValue(String val) { return lookupMap.get(val); } } {code} 1.1 A generic enum inversion For easy usage it is rather useful to have an enum reverse finder as a helper utility and use it whereever useful: {code: type=java} public abstract class EnumReverseFinder<K,V extends Enum<V>> { private Map<K, V> map = new HashMap<K, V>(); public EnumReverseFinder(Class<V> enumclass) { for(V v:enumclass.getEnumConstants()) map.put(getKey(v), v); } public V get(K k) {return map.get(k);} protected abstract K getKey(V value); } {code} On the usage one must define the key by implementing the abstract getKey-Method. The Gender-Enum as an example would look like this: {code:type=java} public enum Gender { MALE("M"), FEMALE("F"); protected String dbValue; public Gender(String s) { dbValue=s; } public String getDbValue() { return dbValue;} // reverse lookup for dbValue private static final EnumReverseFinder<String, Gender> dbValueFinder = new EnumReverseFinder<String, Gender>(Gender.class) { protected String getKey(Gender v){return v.dbValue;} }; public static Gender findbyDbValue(String val){return dbValueFinder.get(val);} } {code} 1.1 More fancy things about enums - checkout this newsletter issue from the great Heinz Kabutz (Javaspecialist): http://www.javaspecialists.eu/archive/Issue113.html - Also this article is useful: http://www.ajaxonomy.com/2007/java/making-the-most-of-java-50-enum-tricks 2010-05-09 14:49:46.223 2010-05-02 18:37:53.109