精华内容
下载资源
问答
  • 场景: 在开发过程中,经常会遇到需要根据枚举的code获取对应name或根据...一、Enum根据code/name获取枚举对象、根据code获取name、根据name获取code。 @Getter @AllArgsConstructor public enum BorrowStatusEnum {

    场景:

    在开发过程中,经常会遇到需要根据枚举的code获取对应name或根据name获取对应code的需求;抑或是需要根据code或name获取对应枚举对象。
    在开发过程中,前端需要获取下拉选择器中的数据项,通常存放数据库字典表中,本文采取返回枚举列表的方式提供。

    一、Enum根据code/name获取枚举对象、根据code获取name、根据name获取code。

        @Getter
        @AllArgsConstructor
        public enum BorrowStatusEnum {
            /**
             * 借基差还款状态
             */
            IN_USE("IN_USE", "使用中"),
            OVERDUE("OVERDUE", "已超期"),
            DEDUCTION("DEDUCTION", "抵扣中"),
            FINISH("FINISH", "已还款");
            /**
             * 状态
             */
            public final String code;
            /**
             * 名称
             */
            public final String name;
    
            /**
             * 根据code查找
             * @param code 枚举code
             * @return 枚举对象
             */
            public static BorrowStatusEnum findEnumByCode(String code) {
                for (BorrowStatusEnum statusEnum : BorrowStatusEnum.values()) {
                    if (statusEnum.getCode().equals(code)) {
                        //如果需要直接返回name则更改返回类型为String,return statusEnum.name;
                        return statusEnum;
                    }
                }
                throw new IllegalArgumentException("code is invalid");
            }
    
            /**
             * 根据name查找
             * @param name 枚举name
             * @return 枚举对象
             */
            public static BorrowStatusEnum findEnumByName(String name) {
                for (BorrowStatusEnum statusEnum : BorrowStatusEnum.values()) {
                    if (statusEnum.getName().equals(name)) {
                        //如果需要直接返回code则更改返回类型为String,return statusEnum.code;
                        return statusEnum;
                    }
                }
                throw new IllegalArgumentException("name is invalid");
            }
    
        }
    
    测试:
        public static void main(String[] args) {
            System.out.println("根据code获取枚举对象:" + BorrowStatusEnum.findEnumByCode("IN_USE"));
            System.out.println("根据name获取枚举对象:" + BorrowStatusEnum.findEnumByName("已还款"));
            
            System.out.println("根据code获取name:" + BorrowStatusEnum.findEnumByCode("IN_USE").name);
            System.out.println("根据name获取code:" + BorrowStatusEnum.findEnumByName("已还款").code);
        }
    
    输出:
    根据code获取枚举对象:IN_USE
    根据name获取枚举对象:FINISH
    根据code获取name:使用中
    根据name获取code:FINISH
    

    二、获取Enum列表

    @Getter
        @AllArgsConstructor
        public enum BorrowStatusEnum {
            /**
             * 借基差还款状态
             */
            IN_USE("IN_USE", "使用中"),
            OVERDUE("OVERDUE", "已超期"),
            DEDUCTION("DEDUCTION", "抵扣中"),
            FINISH("FINISH", "已还款");
            /**
             * 状态
             */
            public final String code;
            /**
             * 名称
             */
            public final String name;
    
            /**
             * 转为数据
             * @return 枚举对象数组
             */
            public static List<Map<String, String>> toList() {
                List<Map<String, String>> list = new ArrayList<>();
                for (BorrowStatusEnum item : BorrowStatusEnum.values()) {
                    Map<String, String> map = new HashMap<>();
                    map.put("code", item.getCode());
                    map.put("name", item.getName());
                    list.add(map);
                }
                return list;
            }
    
        }
    
    测试:
        public static void main(String[] args) {
            System.out.println("enum toString:" + BorrowStatusEnum.toList());
        }
    
    输出:
    enum toString:[{code=IN_USE, name=使用中}, {code=OVERDUE, name=已超期}, {code=DEDUCTION, name=抵扣中}, {code=FINISH, name=已还款}]
    

    三、附上获取Enum列表工具类(使用工具类就不需要每个Enum都加一遍toList方法了!)

    public class EnumUtils {
    
        private static final String ENUM_CLASSPATH ="java.lang.Enum";
    
        public static List<Map<String, Object>> enumToListMap(Class<?> enumClass) {
            List<Map<String, Object>> resultList= new ArrayList<>();
            if (!ENUM_CLASSPATH.equals(enumClass.getSuperclass().getCanonicalName())) {
                return resultList;
            }
            // 获取所有public方法
            Method[] methods = enumClass.getMethods();
            List<Field> fieldList = new ArrayList<>();
            //1.通过get方法提取字段,避免get作为自定义方法的开头,建议使用 ‘find’或其余命名
            Arrays.stream(methods)
                    .map(Method::getName)
                    .filter(
                            methodName -> methodName.startsWith("get") && !"getDeclaringClass".equals(methodName) && !"getClass".equals(methodName)
                    ).forEachOrdered(methodName -> {
                try {
                    Field field = enumClass.getDeclaredField(StringUtils.uncapitalize(methodName.substring(3)));
                    fieldList.add(field);
                } catch (NoSuchFieldException | SecurityException e) {
                    e.printStackTrace();
                }
            });
     
            //2.将字段作为key,逐一把枚举值作为value 存入list
            if (CollectionUtils.isEmpty(fieldList)) {
                return resultList;
            }
     
            Enum[] enums = (Enum[]) enumClass.getEnumConstants();
            for (Enum anEnum : enums) {
                Map<String, Object> map = new HashMap<>(fieldList.size());
                for (Field field : fieldList) {
                    field.setAccessible(true);
                    try {
                        // 向map集合添加字段名称 和 字段值
                        map.put(field.getName(), field.get(anEnum));
                    } catch (IllegalArgumentException | IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                // 将Map添加到集合中
                resultList.add(map);
            }
            return resultList;
        }
     
    }
    
    测试:
        public static void main(String[] args) {
            //调用时需传入枚举类.class
            System.out.println("EnumUtils.enumToListMap:" + EnumUtils.enumToListMap(StatusEnum.BorrowStatusEnum.class));
        }
    
    输出:
    EnumUtils.enumToListMap:[{name=使用中, code=IN_USE}, {name=已超期, code=OVERDUE}, {name=抵扣中, code=DEDUCTION}, {name=已还款, code=FINISH}]
    
    工具类参考博客:https://blog.csdn.net/qq_35387940/article/details/113772411
    展开全文
  • java中常用的枚举方法有values和valueof valueOf方法会把一个String类型的名称...values是获取所有的枚举项 package HtppClient1.EnumUtil; import java.lang.reflect.Field; import java.lang.reflect.Invoc...

     java中常用的枚举方法有values和valueof

    valueOf方法会把一个String类型的名称转变成枚举项,也就是在枚举项中查找字面值和该参数相等的枚举项。

     values是获取所有的枚举项

    package HtppClient1.EnumUtil;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    import org.springframework.util.ReflectionUtils;
    
    import com.sun.org.apache.bcel.internal.generic.IfInstruction;
    
    
    enum TestEnums {
    	weirenzheng(0, "0、未认证;", 16, -1, 0),
        onceTime(1, "上月支付1次及以下;", 8, 0, 1),
        towTimes(2, "上月支付1-2次", 12, 1, 2),
        threeTimes(3, "上月支付3-4次;", 16, 3, 4),
        fiveTimes(4, "上月支付5-7次", 20, 4, 7),
        sixTimes(5, "上月支付7次以上", 24, 7, Integer.MAX_VALUE);
        public int code;//排序
        public String desc;//描述
        public int score;//分值
        public int lower;//最低次数
        public int high;//最高次数
    
        TestEnums() {
        }
    
        TestEnums(int code, String desc, int score, int lower, int high) {
            this.code = code;
            this.desc = desc;
            this.score = score;
            this.lower = lower;
            this.high = high;
        }
    
        public int getCode() {
            return code;
        }
    
        public String getDesc() {
            return desc;
        }
    
    
    
        public int getScore() {
            return score;
        }
    
    
    
        public int getLower() {
            return lower;
        }
    
    
    
        public int getHigh() {
            return high;
        }
        /**
         * 根据code返回枚举值
         * @param Code
         * @return
         */
        public static TestEnums   getEumByCode(int Code){
        	for(TestEnums testEnums: TestEnums.values()) {
        		if(testEnums.getCode()==Code) {
        			return testEnums;
        		}
        	}
        	return null;  	
        }
    
        /**
         * 根据序号获取枚举数组中的值,序号必须从0开始
         * @param key
         * @return
         * @throws IllegalAccessException
         * @throws IllegalArgumentException
         * @throws InvocationTargetException
         * @throws InstantiationException
         */
        public static <T> List<T>   getEumByKey(int Code) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
        	List<String> enumList=getEumValueList();
        	List<T> enumList1=new ArrayList<T>();
        	for(TestEnums testEnums: TestEnums.values()) {
        		if(testEnums.getCode()==Code) {
        			Class<?> clazz=testEnums.getClass();
        			// 获取所有常量
        	        Object object = clazz.getEnumConstants()[Code];
            	    Field[]  filedFields=clazz.getFields();    	            	        	
    				for (Field field : filedFields) {   				
    					field.setAccessible(true);
    					Object sssObject=field.get(object);
    					if(enumList.contains(field.getName())) {
    						continue;
    					}else {
    						if(sssObject!=null)
    							enumList1.add((T) sssObject);
    					}
    				}	
        			return enumList1;
        		}
        	}
        	return null;
        }
        /**
         * 获取枚举值常量列表
         * @param Code
         * @return
         */
        public static List<String>  getEumValueList() {
        		  List<String> list=new ArrayList<String>();
        		  for(Object object:TestEnums.values()) {
    					list.add(object.toString());
        		  }
        		  return list;	
        }
        /**
         * 传入方法名称  values是值 ,field是 字段mingcheng
         * @param <T>
         * @param enumType
         * @param value
         * @param field
         * @return
         * @throws Exception
         */
        public static <T extends Enum<T>> T getEnumOnValue(Class<T> enumType, String value, String field) throws Exception {
    
           for (Object obj : enumType.getEnumConstants()) {
              Method m = obj.getClass().getDeclaredMethod("values", null);
              Object[] results = (Object[]) m.invoke(obj, null);
              for (Object result : results) {
                 Field codeField = result.getClass().getDeclaredField(field);
                 ReflectionUtils.makeAccessible(codeField);
                 String fileValue = String.valueOf(ReflectionUtils.getField(codeField, result));
                 if (fileValue.equals(value)) {
                    return (T) result;
                 }
    
              }
           }
           return null;
        }
    }

    test代码:

    import java.util.List;
    
    /**
     * Hello world!
     *
     */
    public class App 
    {		 
        public static void main( String[] args ) throws Exception
        {
        	TestEnums testEnums = TestEnums.getEnumOnValue(TestEnums.class, "1", "code");
           List<Object> list=TestEnums.getEumByKey(1);
           for (Object string : list) {
    		System.out.println(":"+string);
           }
        }
    }

     

    展开全文
  • 利用JAVA反射获取所有枚举

    千次阅读 2019-05-17 17:57:06
    JAVA反射获取所有枚举定义枚举接口枚举类获取所有枚举输出 定义枚举接口 public interface ... * 获取枚举值 * @returnint */ Integer getValue(); /** * 获取枚举名称 * @return */ String getName...

    定义枚举接口

    public interface BaseEnum {
        /**
         * 获取枚举值
         * @returnint
         */
        Integer getValue();
    
        /**
         * 获取枚举名称
         * @return
         */
        String getName();
    }
    

    枚举类

    @Getter
    public enum TestEnum implements BaseEnum {
        TEST1("name1",1),
        TEST2("name1",2),
        TEST3("name1",3);
    
        private String name;
        private Integer value;
    
        private TestEnum(String name,Integer value){
            this.name = name;
            this.value = value;
        }
    
    }
    

    获取所有枚举

        public static void test4(){
    
            Reflections reflections = new Reflections("com.xxx.modules");
    
            Set<Class<? extends BaseEnum>> monitorClasses = reflections.getSubTypesOf(BaseEnum.class);
    
            System.out.println("size:"+monitorClasses.size());
            monitorClasses.forEach(m->{
                try {
                    System.out.println("name:"+m.getSimpleName());
                    BaseEnum[] enumConstants = m.getEnumConstants();
    
                    for (BaseEnum anEnum : enumConstants) {
                        System.out.println("enumName:"+anEnum+"  value:"+anEnum.getValue()+"  name:"+anEnum.getName());
                    }
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    

    输出

    执行输出结果

    展开全文
  • 参考:... 思路:通过反射获取枚举类的Field,再用 Field 获取 DescriptionAttribute 属性。反之亦然 // 枚举 public enum enumStudent { [Description("性别")] sex = 0, [Descripti...

    参考:https://www.cnblogs.com/jonney-wang/p/6732875.html

    思路:通过反射获取枚举类的Field,再用 Field 获取 DescriptionAttribute 属性。反之亦然

    // 枚举
    public enum enumStudent
    {
        [Description("性别")]
        sex = 0,
        [Description("年龄")]
        age = 1,
    }
    
    // 获取方法
    public string GetDescriptionByEnum(Enum enumValue)
    {
        string value = enumValue.ToString();
        System.Reflection.FieldInfo field = enumValue.GetType().GetField(value);
        object[] objs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);    //获取描述属性
        if (objs.Length == 0)    //当描述属性没有时,直接返回名称
            return value;
        DescriptionAttribute descriptionAttribute = (DescriptionAttribute)objs[0];
        return descriptionAttribute.Description;
    }
    
    
    // 调用示例
    GetDescriptionByEnum(enumStudent.age) → 年龄
    
    
    public T GetEnumByDescription<T>(string description) where T : Enum
    {
        System.Reflection.FieldInfo[] fields = typeof(T).GetFields();
        foreach(System.Reflection.FieldInfo field in fields)
        {
            object[] objs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);    //获取描述属性
            if (objs.Length > 0 && (objs[0] as DescriptionAttribute).Description == description)
            {
                return (T)field.GetValue(null);
            }
        }
    
        throw new ArgumentException(string.Format("{0} 未能找到对应的枚举.", description), "Description");
    }
    
    // 调用示例
    GetEnumByDescription<enumStudent>("性别").ToString() → sex

     

    展开全文
  • c#获取所有枚举

    2018-03-01 10:53:00
    获取所有的枚举 1、将所有的枚举单独成一个项目 2、通Assembly加载程序集 3、通过Assembly对象的GetTypes获取所有的枚举类型 4、通过Enum.GetValues可以得到枚举的所有值 Assembly asmb = Assembly.LoadFrom...
  • 一、声明枚举值、枚举值描述 using System.ComponentModel; public enum status { /// <summary> /// 取消 /// </summary> [Description("取消")] cancel, /// <summary> /// 提交 ///...
  • 枚举获取全部参数

    2020-12-11 21:26:32
    需求:把下面的数个输入项发送到后台处理 一般的操作如下 用枚举的操作如下 枚举后得到的数据如下 总结:当提交的数据量较少时,...反之,当提交的数据量较大时,用枚举循环获取可以减少代码量,方便灵活。 ...
  • * 获取枚举值 * @returnint */ Integer getValue(); /** * 获取枚举名称 * @return */ String getName(); } 枚举类 @Getter public enum TestEnum implements BaseEnum { TEST1("name1",1
  • 获取枚举里的所有枚举

    千次阅读 2019-10-12 11:56:53
    using UnityEngine; using System;.../// 获取枚举里的所有枚举 /// </summary> public class 枚举测试 : MonoBehaviour { private void 测试() { var arr = Enum.GetValues(typeof(测试枚举)...
  • java 通过反射获取枚举类,及枚举类的值,枚举类枚举实例名。本项目为普通java项目
  • 为了解决获取枚举的所有枚举项,我们将枚举封装为枚举类EnumNode,并扩展获取所有枚举项的扩展方法ToSelectList,详细代码如下: ------------------------------------------------------Enum...
  • 前端获取所有枚举

    千次阅读 2019-07-25 11:25:39
    在实际项目中,有很多用到枚举的地方,比如状态 类别等,很多时候在列表查询的时候,这些状态都是作为查询条件的,所以就需要前端老哥发请求到后台来查询枚举值,这里需要注意了,一般情况下,别让前端老哥写死了,这是很不...
  • 没有优化,凑合着用吧。需要using System.... /// 根据属性描述获取枚举值 /// </summary> /// <typeparam name="T">类型</typeparam> /// <param name="des">属性说明</param&...
  • 根据枚举的value获取枚举

    千次阅读 2018-09-18 15:35:56
     根据枚举的value获取枚举 二、代码   /// &lt;summary&gt; /// 根据枚举的value获取枚举 /// &lt;/summary&gt; /// &lt;param name="enumType"&gt;枚举的类型,示例:...
  • 根据枚举的key获取枚举

    千次阅读 2018-09-18 14:34:52
     通过枚举的key获取枚举 二、代码  /// &lt;summary&gt; /// 根据枚举的key获取枚举 /// &lt;/summary&gt; /// &lt;param name="enumType"&gt;枚举的类型,示例:typeof...
  • 获取枚举

    2018-11-08 19:53:50
    TableEnumFields build = TableEnumFields.build("4"); 枚举值 获取枚举值  
  • 只用过枚举遍历法,但是不知道怎么样才能遍历枚举中的全部元素,得到一个数组,希望大神们指教
  • 不多说了,直接看代码吧,我这边使用了一个一次性的方法.../// 获取所有枚举名字 /// </summary> /// <returns></returns> List<string> GetAdditionTypeNames() { List<string> nam...
  • 枚举局域网内计算机 VC6编译通过,很方便
  • 有时候,有一些下拉选择器的数据项,我们采取了枚举的方式简单记录,但是里面的东西多,前端不想写死,需要提供接口返回。 示例: 枚举 /** * @Author: JCccc * @Description: * @Date: Create in 10:51 2021...
  • 介绍了C# 获取枚举值的简单实例,有需要的朋友可以参考一下
  • Java根据枚举名使用反射获取枚举

    千次阅读 2018-12-12 18:36:26
    由于前端需要根据枚举名获取实时获取枚举值,所以通过反射去得到枚举数据. (一) 首先我们新建一个枚举类接口,用于之后反射使用 package com.littlematch.enums.biz; /** * 枚举值接口定义类 */ public interface ...
  • 枚举类中获取枚举值的几种方法

    万次阅读 2019-03-17 21:02:36
    在开发的过程中我们经常会定义枚举类,枚举类中获取枚举值的方式也有很多种,下面我们就探究一下大家常用的几种方式: 枚举类 public enum TestEnum { ONE(1,"one"), ZERO(0,"zero"), TWO(2,...
  • 示例假设我们有一个枚举DayOfWeek:enumDayOfWeek{SUNDAY,MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY;}枚举使用内置的静态valueOf()方法进行编译,该静态方法可用于按其名称查找常量:StringdayName=...
  • public enum color {red=1,green=2,blue=3} Type typ = typeof(color);   1、根据 索引获取 字符串 结果为 “red” 字符串 ...2、根据字符串获取索引 结果为 0string s = Enum.Format(typ, Enum.Parse(ty...
  • java枚举结果类、根据状态值获取枚举值 Controller: /** 模块类型枚举 */ model.addAttribute("mType", ModuleTypeEnum.ModuleTypeShow()); ftl: value="${mType.key}:${mType.value}” </#list>
  • 枚举扩展方法 1 /// &lt;summary&gt; 2 /// 扩展方法,获得枚举的Description 3 /// &lt;/summary&gt; 4 /// &lt;param name="value"&gt;枚举值&lt;/param&gt;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 246,321
精华内容 98,528
关键字:

获取全部枚举