将Enum枚举转成Map，List结构

 JAVA枚举功能强大，感觉就像是一种简化版的类对象，可以有构造方法，可以重载，可以继承接口等等，JAVA枚举在实际开发中应用相当频繁，以下几个封装方法在实际开发中可能用到，将枚举类转化为Map以及List结构的一些操作方法。

首先，新建一个枚举接口，为保证所有继承此接口的枚举value及typeName一致，便于开发使用，枚举统一接口如下。

public interface EnumCommonFacade {
    public String getValue();
    public String getTypeName();
}

1、接下来新建一个枚举类并集成EnumCommonFacade 接口：

public enum AgentIdTypeEnum implements EnumCommonFacade{
    ID_CARE("idCare", "身份证"),
    OFFCIAL_CARE("offcialCare", "军官证"),
    PASSPORT("passport", "护照"),
    DRIVING_CARE("drivingCare", "驾照"),
    HOUSEHOLD_CARE("householdCare", "户口本"),
    LAWYER_CARE("lawyerCare", "律师执业证"),
    PRACTICE_LAWYER_CARE("practiceLawyerCare", "实习律师证");
    /**枚举value字段*/
    private String value;
    /**枚举描述字段*/
    private String typeName;
    @Override
    public String getValue() {
        return value;
    }
    @Override
    public String getTypeName() {
        return typeName;
    }
    /**构造初始化赋值*/
    AgentIdTypeEnum(String value,String typeName){
        this.typeName=typeName;
        this.value=value;
    }
}

2、新建EnumUtils工具类：

package utils;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 工具类
 * @author 123456
 *
 */
public class EnumUtils {
	  /**
     * 枚举转map结合value作为map的key,description作为map的value
     *
     * @param enumT
     * @param methodNames
     * @return enum mapcolloction
     */
    public static <T> Map<Object, String> EnumToMap(Class<T> enumT,
                                                    String... methodNames) {
        Map<Object, String> enummap = new HashMap<Object, String>();
        if (!enumT.isEnum()) {
            return enummap;
        }
        T[] enums = enumT.getEnumConstants();
        if (enums == null || enums.length <= 0) {
            return enummap;
        }
        int count = methodNames.length;
        /**默认接口value方法*/
        String valueMathod = "getValue";
        /**默认接口typeName方法*/
        String desMathod = "getTypeName";
        /**扩展方法*/
        if (count >= 1 && !"".equals(methodNames[0])) {
            valueMathod = methodNames[0];
        }
        if (count == 2 && !"".equals(methodNames[1])) {
            desMathod = methodNames[1];
        }
        for (int i = 0, len = enums.length; i < len; i++) {
            T tobj = enums[i];
            try {
                /**获取value值*/
                Object resultValue = getMethodValue(valueMathod, tobj);
                if ("".equals(resultValue)) {
                    continue;
                }
                /**获取typeName描述值*/
                Object resultDes = getMethodValue(desMathod, tobj);
                /**如果描述不存在获取属性值*/
                if ("".equals(resultDes)) {
                    resultDes = tobj;
                }
                enummap.put(resultValue, resultDes + "");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return enummap;
    }

    /**
     * 根据反射，通过方法名称获取方法值，忽略大小写的
     *
     * @param methodName
     * @param obj
     * @param args
     * @return return value
     */
    private static <T> Object getMethodValue(String methodName, T obj, Object... args) {
        Object resut = "";
        try {
            /********************************* start *****************************************/
            /**获取方法数组，这里只要共有的方法*/
            Method[] methods = obj.getClass().getMethods();
            if (methods.length <= 0) {
                return resut;
            }
            Method method = null;
            for (int i = 0, len = methods.length; i < len; i++) {
                /**忽略大小写取方法*/
                if (methods[i].getName().equalsIgnoreCase(methodName)) {
                    /**如果存在，则取出正确的方法名称*/
                    methodName = methods[i].getName();
                    method = methods[i];
                    break;
                }
            }
            /*************************** end ***********************************************/
            if (method == null) {
                return resut;
            }
            /**方法执行*/
            resut = method.invoke(obj, args);
            if (resut == null) {
                resut = "";
            }
            /**返回结果*/
            return resut;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resut;
    }

    /**
     * 通过value值获取对应的描述信息
     *
     * @param value
     * @param enumT
     * @param methodNames
     * @return enum description
     */
    public static <T> Object getEnumDescriotionByValue(Object value, Class<T> enumT, String... methodNames) {
        /**不是枚举则返回""*/
        if (!enumT.isEnum()) {
            return "";
        }
        /**获取枚举的所有枚举属性，似乎这几句也没啥用，一般既然用枚举，就一定会添加枚举属性*/
        T[] enums = enumT.getEnumConstants();
        if (enums == null || enums.length <= 0) {
            return "";
        }
        int count = methodNames.length;
        /**默认获取枚举value方法，与接口方法一致*/
        String valueMathod = "getValue";
        /**默认获取枚举getTypeName方法*/
        String desMathod = "getTypeName";
        if (count >= 1 && !"".equals(methodNames[0])) {
            valueMathod = methodNames[0];
        }
        if (count == 2 && !"".equals(methodNames[1])) {
            desMathod = methodNames[1];
        }
        for (int i = 0, len = enums.length; i < len; i++) {
            T t = enums[i];
            try {
                /**获取枚举对象value*/
                Object resultValue = getMethodValue(valueMathod, t);
                if (resultValue.toString().equals(value + "")) {
                    /**存在则返回对应描述*/
                    Object resultDes = getMethodValue(desMathod, t);
                    return resultDes;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "";
    }

    /**
     * 通过枚举value或者自定义值及方法获取枚举属性值
     *
     * @param value
     * @param enumT
     * @param methodNames
     * @return enum key
     */
    public static <T> String getEnumKeyByValue(Object value, Class<T> enumT, String... methodNames) {
        if (!enumT.isEnum()) {
            return "";
        }
        T[] enums = enumT.getEnumConstants();
        if (enums == null || enums.length <= 0) {
            return "";
        }
        int count = methodNames.length;
        /**默认方法*/
        String valueMathod = "getValue";
        /**独立方法*/
        if (count >= 1 && !"".equals(methodNames[0])) {
            valueMathod = methodNames[0];
        }
        for (int i = 0, len = enums.length; i < len; i++) {
            T tobj = enums[i];
            try {
                Object resultValue = getMethodValue(valueMathod, tobj);
                /**存在则返回对应值*/
                if (resultValue != null && resultValue.toString().equals(value + "")) {
                    return tobj + "";
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "";
    }
    
    /**
     * 转换成List
     * @param enumT
     * @param methodNames
     * @return List<String>
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
	public static <T> List<String> getEnumToList(Class<T> enumT,String... methodNames){
        Map<Object, String> map = EnumToMap(enumT);
        List<String> result = new ArrayList(map.values());
		return result;
    }
}

3、编写测试类进行测试：

package test;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

import common.common.AgentIdTypeEnum;
import utils.EnumUtils;

public class Test {

	public static void main(String[] args) {
	     Class<AgentIdTypeEnum> clasz=AgentIdTypeEnum.class;
	     Map<Object, String>  map=EnumUtils.EnumToMap(clasz);
	     System.out.println("获取枚举的map集合----------："+map);
	     String des=(String) EnumUtils.getEnumDescriotionByValue("idCare", clasz);
	     System.out.println("获取值为idCare的描述------------："+des);
	     
	     Object valueget=EnumUtils.getEnumDescriotionByValue("护照", clasz,"getTypeName","getValue");
	     System.out.println("获取  护照的value值-----："+valueget);
	     
	     String field=(String) EnumUtils.getEnumKeyByValue("idCare", clasz);
	     System.out.println("获取值为idCare的属性字段--------："+field);
	     
	     String fielda=(String) EnumUtils.getEnumKeyByValue("护照", clasz,"getTypeName");
	     System.out.println("获取 护照的属性字段----："+fielda);
	     
	     AgentIdTypeEnum str=  Enum.valueOf(AgentIdTypeEnum.class,"ID_CARE");	    
	      System.out.println("根据字段名称取值---------："+ str.getValue());
		  System.out.println("获取枚举所有字段---------："+ Arrays.toString(AgentIdTypeEnum.values()));
		  
		  List<String> result = EnumUtils.getEnumToList(clasz);
		  System.out.println("转成List---------："+ result.toString());
	}

}

4、测试返回结果：