Java列举的反向查找

副标题#e#

java的列举经常被用来替代常量值，每个列举值代表一个特定的常数。

在反序列化时有经常需要用到常数到列举的转换，这就涉及到列举的反向查找。

1、从列举名反向查找列举

这种要领是最先利用也最为轻便的

可以用到列举的静态要领valueOf(String name)

valueOf要领为内置要领，利用轻便，但在查找不到列举时会抛出异常。

熟悉异常的同学大概知道异常抛出时，需要收集虚拟机的挪用仓库上下文信息，对机能影响较大。

利用时，经常需要利用这么一个反序列化查找要领

E find(String name, E defaultValue)，在查找不到时可以或许返回一个默认值而不是抛出异常

2、从列举值所包括的描写值反向查找列举

譬喻这种列举界说

public enum SomeEnum{
    A("ADes", 1),
    B("BDes", 2),
    unknown("UNKNWONDes", 3);
     
    private string des;
    private int order;
     
    private SomeEnum(string des, int order){
        this.des = des;
        this.order = order;
    }
}

此时可以在列举类中增加一个HashMap，并在类加载时初始化好。

public enum SomeEnum{
    A("ADes"),
    B("BDes"),
    unknown("UNKNWONDes");
     
    private string des;
     
    private static final map lookup = new hashmap();
     
    static {
        for(SomeEnum e : EnumSet.allOf(SomeEnum.class)){
            lookup.put(e.des, e);
        }
    }
     
    private SomeEnum(string des){
        this.des = des;
    }
     
    public static SomeEnum find(string des, SomeEnum defaultValue){
        SomeEnum value = lookup.get(des);
        if(value == null){
            return defaultValue;
        }
        return value;
    }
}

3、进一步，假如列举中有多个描写值，而且描写值范例纷歧样

这时初始化代码和查找代码需要写多遍。

public enum SomeEnum{
    A("ADes", 1),
    B("BDes", 2),
    unknown("UNKNWONDes", 3);
     
    private string des;
    private int order;
     
    private static final map lookup = new hashmap();
     
    private static final map lookup_int = new hashmap();
     
    static {
        for(SomeEnum e : EnumSet.allOf(SomeEnum.class)){
            lookup.put(e.des, e);
            lookup_int.put(e.order, e);
        }
    }
     
    private SomeEnum(string des, int order){
        this.des = des;
        this.order = order;
    }
     
    public static SomeEnum find(string des, SomeEnum defaultValue){
        SomeEnum value = lookup.get(des);
        if(value == null){
            return defaultValue;
        }
        return value;
    }
     
    public static SomeEnum find(int order, SomeEnum defaultValue){
        SomeEnum value = lookup_int.get(order);
        if(value == null){
            return defaultValue;
        }
        return value;
    }
}

不少代码有反复，

列举类需要本身实现反向查找映射干系在HashMap中的初始化。

按照DRY原则，反复代码处所一般都有必然的坏味道。

查察本栏目

#p#副标题#e#

4、改造

列举的反向查找其实只需存眷两件工作，

a 提供列举值描写到列举值的映射

b 能从列举值描写查找到列举值，查找不到能提供默认值

据此，可以提炼出列举反向查找的辅佐类：

public class EnumFindHelper<T extends Enum<T>, K> {
    protected Map<K, T> map = new HashMap<K, T>();
     
    public EnumFindHelper(Class<T> clazz, EnumKeyGetter<T, K> keyGetter) {
        try {
            for (T enumValue : EnumSet.allOf(clazz)) {
                map.put(keyGetter.getKey(enumValue), enumValue);
            }
        } catch (Exception e) {
            //eror handler
        }
    }
     
    public T find(K key, T defautValue) {
        T value = map.get(key);
        if (value == null) {
            value = defautValue;
        }
        return value;
    }
}

这里需要一个接口界说：

public static interface EnumKeyGetter<T extends Enum<T>, K> {
     
        K getKey(T enumValue);
     
}

查找辅佐类EnumFindHelper结构时需要EnumKeyGetter来提供列举值到列举范例的的对应干系。

界说列举类时实现EnumKeyGetter接口，并传入EnumFindHelper。

修改后的列举界说大概为：

public enum SomeEnum{
    A("ADes", 1),
    B("BDes", 2),
    unknown("UNKNWONDes", 3);
     
    private String des;
    private int order;
     
    private SomeEnum(string des, int order){
        this.des = des;
        this.order = order;
    }
     
    static final EnumFindHelper<SomeEnum, String> desptHelper = new EnumFindHelper<SomeEnum, String>(
        SomeEnum.class, new DesptGetter());
             
    static final EnumFindHelper<SomeEnum, Integer> orderHelper = new EnumFindHelper<SomeEnum, Integer>(
        SomeEnum.class, new OrderKeyGetter());
     
    static class DesptGetter implements EnumKeyGetter<SomeEnum, String> {
        @Override
        public String getKey(SomeEnum enumValue) {
            return enumValue.des;
        }
    }
         
    static class OrderKeyGetter implements EnumKeyGetter<SomeEnum, Integer> {
        @Override
        public String Integer(SomeEnum enumValue) {
            return enumValue.order;
        }
    }
         
    public static SomeEnum find(string despt, SomeEnum defaultValue){
        return desptHelper.find(des, defaultValue);
    }
     
    public static SomeEnum find(int order, SomeEnum defaultValue){
        return orderHelper.find(des, defaultValue);
    }
}

EnumFindHelper内部类的界说有些繁琐，不外java8之后用lambda实现后会轻便一些。

5 总结

每个列举类的反向查找成果委托一个辅佐类来实现，从列举类的结构上来看，较量雷同GOF的桥接模式。

而从委托类的实现查找成果来看，需要一个EnumKeyGetter接口，每种差异的接话柄现差异的查找方法，有按照描写字符查找，有按照列举顺序值查找。

这又有些雷同GOF的计策模式。

虽然不需要去纠结于哪种设计模式，代码的设计就是要求代码不冗余，成果的重用，依赖的解耦。

上面的设计中：

1）操作EnumFindHelper做到列举查找的算法重用，操作一个map提供列举描写到列举值的查找。

2）EnumFindHelper初始化时需要结构好查找用的map，所以会依赖于详细的列举界说。

这里抽象出EnumKeyGetter，EnumFindHelper由依赖于详细的列举类改为依赖于EnumKeyGetter接口，在结构时注入了EnumKeyGetter的实现。

这么看起来是不是有些DPI（依赖注入）的感受？！