自定义枚举类型的常用操作-附源码(xjl456852原创)

自定义枚举类型中,假如我们有name和desc这样的属性,并在这个基础上定义了多个对象.

那么就可能用到通过name获取desc,或者通过desc获取name.通过name或者desc获取对应的枚举对象的名称或ordinal等等.

我们可以定义一个接口,所有的枚举类型都实现这个接口,这样使用会更方便.

直接上代码,看看如何方便的操作这些需求.

定义一个接口:

package com.xjl456852.myenum;
/**
 * Created by xiejianglei on 2017/1/9.
 */
public interface TestEnum {
    String code();
    String desc();
    //这个方法是子类枚举类型自带的方法,子类无需实现,也无法实现
    String name();
    //这个方法是子类枚举类型自带的方法,子类无需实现,也无法实现
    int ordinal();
}

自定义枚举类型,实现定义的接口:

package com.xjl456852.myenum;
/**
 * Created by xiejianglei on 2017/1/9.
 */
public enum TestSubEnum implements TestEnum {
    
    MALE("1","man"),FEMALE("2", "woman");
    private final String code;
    private final String desc;
    TestSubEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }
    @Override
    public String code() {
        return this.code;
    }
    @Override
    public String desc() {
        return this.desc;
    }
}

写个工具类:

package com.xjl456852.myenum;
/**
 * Created by xiejianglei on 2017/1/9.
 */
public class Util {
    /**
     * 通过code获取desc
     * @param code
     * @param type
     * @param <T>
     * @return
     */
    public static <T>String getDescByCode(String code, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                if (constant.code().equalsIgnoreCase(code)) {
                    return constant.desc();
                }
            }
        }
        return null;
    }
    /**
     * 通过desc获取code
     * @param name
     * @param type
     * @param <T>
     * @return
     */
    public static <T>String getCodeByDesc(String name, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                if (constant.desc().equalsIgnoreCase(name)) {
                    return constant.code();
                }
            }
        }
        return null;
    }
    /**
     * 通过desc获取对应EnumName对象的名称
     * @param name
     * @param type
     * @param <T>
     * @return
     */
    public static <T>String getEnumNameByDesc(String name, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                if (constant.desc().equalsIgnoreCase(name)) {
                    return constant.name();
                }
            }
        }
        return null;
    }
    /**
     * 通过code获取对应EnumName对象的名称
     * @param code
     * @param type
     * @param <T>
     * @return
     */
    public static <T>String getEnumNameByCode(String code, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                if (constant.code().equalsIgnoreCase(code)) {
                    return constant.name();
                }
            }
        }
        return null;
    }
    /**
     * 通过code或desc获取对应EnumName对象的名称
     * @param any
     * @param type
     * @param <T>
     * @return
     */
    public static <T>TestEnum getEnumTypeByAny(String any, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                if (constant.code().equalsIgnoreCase(any) || constant.desc().equalsIgnoreCase(any)) {
                    return constant;
                }
            }
        }
        return null;
    }
    /**
     * 通过EnumName对象的名称,获取对应的枚举对象
     * @param enumName
     * @param type
     * @param <T>
     * @return
     */
    public static <T>TestEnum getEnumTypeByEnumName(String enumName, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                //也可以使用constant.toString()替代constant.name()
                if (constant.name().equalsIgnoreCase(enumName)) {
                    return constant;
                }
            }
        }
        return null;
    }
    /**
     * 通过code或desc获取对应ordinal值
     * @param any
     * @param type
     * @param <T>
     * @return
     */
    public static <T>int getOrdinalByAny(String any, Class<T>type) {
        if (type.isEnum()) {
            for (TestEnum constant : (TestEnum[])type.getEnumConstants()){
                if (constant.code().equalsIgnoreCase(any) || constant.desc().equalsIgnoreCase(any)) {
                    return constant.ordinal();
                }
            }
        }
        return -1;
    }
}

测试方法:

package com.xjl456852.myenum;
import static com.xjl456852.myenum.Util.*;
/**
 * Created by xiejianglei on 2017/1/9.
 */
public class TestMain {
    public static void main(String args[]) {
        String code = "1";
        String desc = "man";
        String enumName = "MALE";
        //通过枚举类型自带方法获取枚举类型的名字
        System.out.println(TestSubEnum.MALE.name());
        //通过自定义枚举类型的code,获取枚举类型的desc
        System.out.println(getDescByCode(code, TestSubEnum.class));
        //通过自定义枚举类型的desc,获取枚举类型的code
        System.out.println(getCodeByDesc(desc, TestSubEnum.class));
        
        //通过自定义枚举类型的code,获取枚举类型的名字
        System.out.println(getEnumNameByCode(code, TestSubEnum.class));
        //通过自定义枚举类型的desc,获取枚举类型的名字
        System.out.println(getEnumNameByDesc(desc, TestSubEnum.class));
        //通过自定义枚举类型的code或desc,获取枚举类型对象
        System.out.println(getEnumTypeByAny(code, TestSubEnum.class));
        //通过自定义枚举类型的code或desc,获取枚举类型对象
        System.out.println(getEnumTypeByAny(desc, TestSubEnum.class));
        
        //通过自定义枚举类型的code或desc,获取枚举类型的ordinal
        System.out.println(getOrdinalByAny(code, TestSubEnum.class));
        
        //通过自定义枚举类型的对象名称,获取对应枚举类型的对象
        System.out.println(getEnumTypeByEnumName(enumName, TestSubEnum.class));
    }
}

测试结果如下:

MALE

man

MALE

来自为知笔记(Wiz)