java读取枚举类的值转成list和map方式
作者：不写bug的程序媛
这篇文章主要介绍了java读取枚举类的值转成list和map方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
java读取枚举类的值转成list和map
首先Enum类
public enum RuleTypeEnum {
//officeClerk,estimator,administrator,personnel都是国际化的key值
officeClerk("officeClerk",99),
estimator("estimator",1),
administrator("administrator",2),
personnel("personnel",3);
private String reason;
private int index;
RuleTypeEnum(String reason, int index) {
this.reason = reason;
this.index = index;
}
public String getReason() {
return reason;
}
public void setReason(String reason) {
this.reason = reason;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}下面为Enum工具类
public class EnumUtils {
private static Logger log= LoggerFactory.getLogger(EnumUtils.class);
/**
* 把枚举类的值都转成Map
* @param enumT 枚举类
* @param methodNames 读取的方法
* @param <T>
* @return
*/
public static <T> Map<String, String> EnumToMap(Class<T> enumT,String... methodNames) {
Map<String, String> enummap = new HashMap<String, String>();
if (!enumT.isEnum()) { //如果不是enum
return enummap;
}
T enums []= enumT.getEnumConstants(); //得到枚举类里的实例
if (enums == null || enums.length <= 0) {
return enummap;
}
int count = methodNames.length;
/**默认接口key方法*/
String keyMathod = "getReason";
/**默认接口value方法*/
String valueMathod = "getIndex";
if (count >= 1 && !"".equals(methodNames[0])) {
keyMathod = methodNames[0];
}
if (count == 2 && !"".equals(methodNames[1])) {
valueMathod = methodNames[1];
}
for (int i = 0;i < enums.length; i++) {
T tobj = enums[i];
try {
/**获取key值*/
Object resultkey = getMethodValue(keyMathod, tobj);
if ("".equals(resultkey)) {
continue;
}
/**获取value值*/
Object resultValue = getMethodValue(valueMathod, tobj);
/**如果描述不存在获取整条enum*/
if ("".equals(resultValue)) {
resultValue = tobj;
}
enummap.put(resultkey+"", resultValue+"");
} catch (Exception e) {
e.printStackTrace();
log.error("枚举类转成Map异常",e);
}
}
return enummap;
}
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;
}
/***
* 取枚举的key 和 value 返回list
* @param enumT 枚举类
* @param methodNames 取枚举类的方法
* @param <T>
* @return
*/
public static <T> List<EnumEntity> getEnumToList(Class<T> enumT, String... methodNames) {
List<EnumEntity> enumList = new ArrayList<>(); //最终返回的list enumEntity是对枚举类的封装实体
if (!enumT.isEnum()) {
return enumList;
}
T enums[] = enumT.getEnumConstants(); //得么枚举类里所有的枚举类
if (enums.length == 0) { //如果没有枚举键和值 结束
return enumList;
}
int count = methodNames.length;
String keyMethod = "getReason"; //默认的取 key的方法
String valueMethod = "getIndex"; //默认的取 value 的方法
if (count >= 1 && !methodNames[0].equals("")) { //如果方法的长度是大于等于1的,并且不为空
keyMethod = methodNames[0];
}
if (count == 2 && !methodNames[1].equals("")) { //如果方法的长度是等于2的,并且不为空
valueMethod = methodNames[1];
}
try {
for (int i = 0; i < enums.length; i++) {
EnumEntity enumEntity = new EnumEntity();
T object = enums[i]; //得到枚举类里每条值
Object resultKey = getMethodValue(keyMethod, object); //获取key值
if (resultKey.equals("")) {
continue;
}
Object resultValue = getMethodValue(valueMethod, object); //获取value值
if (resultValue.equals("")) {
resultValue = object;
}
//MessageUtils.getMessage为读取国际化的.
enumEntity.setKey(MessageUtils.getMessage(resultKey.toString())); //把key存到实体类
enumEntity.setValue(resultValue.toString()); //把value存到实体类
enumList.add(enumEntity); //存到list
}
} catch (Exception e) {
e.getStackTrace();
log.error("枚举类转成List异常", e);
}
return enumList;
}
}下面是调用的方法
public List<EnumEntity> getRuleType() { Class<RuleTypeEnum> clasz= RuleTypeEnum.class; List<EnumEntity> list= EnumUtils.getEnumToList(clasz);
//用默认的方法名 getReason和getIndex return list; }完美~
通用java枚举类转List-Map集合
java的枚举类功能是很强大的，在平时开发中也用的比较多，有时候可能会有将枚举类转成List集合这种需求，如果能确定枚举类中的字段固定可以使用实体类接收，如果不固定的话，很多时候只能用Map来接收了。
这里实现一下java枚举类转List-Map集合
/**
* java枚举类转List<Map>集合
*
* @param clazz
* @return null-该class不是枚举类型 []-该枚举类型没有自定义字段 list-获取该枚举类型的List<Map>返回结果
*/
public static List<Map<String, Object>> enumToListMap(Class<?> clazz) {
List<Map<String, Object>> resultList = null;
// 判断是否是枚举类型
if ("java.lang.Enum".equals(clazz.getSuperclass().getCanonicalName())) {
resultList = new ArrayList<>();
// 获取所有public方法
Method[] methods = clazz.getMethods();
List<Field> fieldList = new ArrayList<>();
for (int i = 0; i < methods.length; i++) {
String methodName = methods[i].getName();
if (methodName.startsWith("get") && !"getDeclaringClass".equals(methodName)
&& !"getClass".equals(methodName)) { // 找到枚举类中的以get开头的(并且不是父类已定义的方法)所有方法
Field field = null;
try {
field = clazz.getDeclaredField(StringUtils.uncapitalize(methodName.substring(3))); // 通过方法名获取自定义字段
} catch (NoSuchFieldException | SecurityException e) {
e.printStackTrace();
}
if (field != null) { // 如果不为空则添加到fieldList集合中
fieldList.add(field);
}
}
}
if (!fieldList.isEmpty()) { // 判断fieldList集合是否为空
Map<String, Object> map = null;
Enum<?>[] enums = (Enum[])clazz.getEnumConstants(); // 获取所有枚举
for (int i = 0; i < enums.length; i++) {
map = new HashMap<>();
for (int l = 0, len = fieldList.size(); l < len; l++) {
Field field = fieldList.get(l);
field.setAccessible(true);
try {
map.put(field.getName(), field.get(enums[i])); // 向map集合添加字段名称 和 字段值
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
}
resultList.add(map);// 将Map添加到集合中
}
}
}
return resultList;
}新建几个枚举类和普通类测试一下
public class TestEnum0 {
}public enum TestEnum1 {
TestEnum1;
}public enum TestEnum2 {
TestEnum2("TestEnum2");
private String name;
TestEnum2(String name) {
this.name = name;
}
public String getName() {
return name;
}
}public enum TestEnum3 {
TestEnum3(1, "TestEnum3", "测试枚举类");
private int id;
private String message;
private String desc;
TestEnum3(int id, String message, String desc) {
this.id = id;
this.message = message;
this.desc = desc;
}
public int getId() {
return id;
}
public String getMessage() {
return message;
}
public String getDesc() {
return desc;
}
}编写测试方法
@Test
public void enumToListMapTest() {
// 普通类
System.out.println(enumToListMap(TestEnum0.class));
// 枚举类
System.out.println(enumToListMap(TestEnum1.class));
System.out.println(enumToListMap(TestEnum2.class));
System.out.println(enumToListMap(TestEnum3.class));
}运行结果：
null
[]
[{name=TestEnum2}]
[{id=1, message=TestEnum3, desc=测试枚举类}]
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。