将Enum枚举转成Map,List结构(转)

2019/08/05 11:03
阅读数 713

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;
    }
}
View Code

 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;
    }
}
View Code

 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());
    }
 
}
View Code

 

 

4.原文地址  https://blog.csdn.net/qq_756589808/article/details/89154139

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部