精华内容
下载资源
问答
  • java枚举结果类、根据状态值获取枚举值 Controller: /** 模块类型枚举 */ model.addAttribute("mType", ModuleTypeEnum.ModuleTypeShow()); ftl: value="${mType.key}:${mType.value}” </#list>
  • 动态修改Java 枚举类的

    千次阅读 2018-09-28 16:56:10
    import java.lang.reflect.AccessibleObject; import java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util....

    参考地址:111

    package com.itmuch.empty;
    
    import javassist.ClassPool;
    import javassist.CtClass;
    import javassist.CtField;
    import sun.reflect.ConstructorAccessor;
    import sun.reflect.FieldAccessor;
    import sun.reflect.ReflectionFactory;
    
    import java.lang.reflect.AccessibleObject;
    import java.lang.reflect.Array;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class DynamicEnumUtil {
    
        public static void addField(String classname, String[] fields) throws Exception {
            ClassPool pool = ClassPool.getDefault();
            // pool.appendClassPath(new LoaderClassPath(ByteUtil.class.getClassLoader()));
            //		pool.insertClassPath(Thread.currentThread().getContextClassLoader().getResource(".").getFile());
            CtClass cc = pool.get(classname);
            for (String field : fields) {
                field = field.trim().toUpperCase();
                CtField ctf = new CtField(cc, field, cc);
                ctf.setModifiers(Modifier.PUBLIC);
                cc.addField(ctf);
            }
            Class c = cc.toClass();
            addEnum(c, fields, new Class<?>[] {}, new Object[] {});
        }
    
        public static <T> void addEnum(Class enumType, String[] enumNames, Class<?>[] paramClass, Object[] paramValue) {
            // 0. Sanity checks
            if (!Enum.class.isAssignableFrom(enumType)) {
                throw new RuntimeException("class " + enumType + " is not an instance of Enum");
            }
            // 1. Lookup "$VALUES" holder in enum class and get previous enum instances
            Field valuesField = null;
            Field[] fields = enumType.getDeclaredFields();
            Method[] methods = enumType.getDeclaredMethods();
            for (Field field : fields) {
                if (field.getName().contains("$VALUES")) {
                    valuesField = field;
                    break;
                }
            }
            AccessibleObject.setAccessible(new Field[] { valuesField }, true);
            try {
                for (String enumName : enumNames) {
                    enumName = enumName.trim().toUpperCase();
                    // 2. Copy it
                    T[] previousValues = (T[]) valuesField.get(enumType);
                    List<T> values = new ArrayList<T>(Arrays.asList(previousValues));
                    // 3. build new enum
                    T newValue = (T) makeEnum(enumType, // The target enum class
                            enumName, // THE NEW ENUM INSTANCE TO BE DYNAMICALLY ADDED
                            values.size(),
                            // new Class<?>[] {}, // could be used to pass values to the enum constuctor if needed
                            paramClass,
                            // new Object[] {}
                            paramValue); // could be used to pass values to the enum constuctor if needed
    
                    // 4. add new value
                    values.add(newValue);
                    Object object = values.toArray((T[]) Array.newInstance(enumType, 0));
                    // 5. Set new values field
                    setFailsafeFieldValue(valuesField, null, object);
                    // 6. Clean enum cache
                    cleanEnumCache(enumType);
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    
        private static Object makeEnum(Class<?> enumClass, String value, int ordinal, Class<?>[] additionalTypes, Object[] additionalValues) throws Exception {
            Object[] parms = new Object[additionalValues.length + 2];
            parms[0] = value;
            parms[1] = Integer.valueOf(ordinal);
            System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length);
            return enumClass.cast(getConstructorAccessor(enumClass, additionalTypes).newInstance(parms));
        }
    
        private static ConstructorAccessor getConstructorAccessor(Class<?> enumClass, Class<?>[] additionalParameterTypes) throws NoSuchMethodException {
            Class<?>[] parameterTypes = new Class[additionalParameterTypes.length + 2];
            parameterTypes[0] = String.class;
            parameterTypes[1] = int.class;
            System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length);
            return reflectionFactory.newConstructorAccessor(enumClass.getDeclaredConstructor(parameterTypes));
        }
    
        private static ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
    
        private static void setFailsafeFieldValue(Field field, Object target, Object value) throws NoSuchFieldException, IllegalAccessException {
    
            // let's make the field accessible
            field.setAccessible(true);
            // next we change the modifier in the Field instance to
            // not be final anymore, thus tricking reflection into
            // letting us modify the static final field
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            int modifiers = modifiersField.getInt(field);
    
            // blank out the final bit in the modifiers int
            modifiers &= ~Modifier.FINAL;
            modifiersField.setInt(field, modifiers);
    
            FieldAccessor fa = reflectionFactory.newFieldAccessor(field, false);
            fa.set(target, value);
        }
    
        private static void blankField(Class<?> enumClass, String fieldName) throws NoSuchFieldException, IllegalAccessException {
            for (Field field : Class.class.getDeclaredFields()) {
                if (field.getName().contains(fieldName)) {
                    AccessibleObject.setAccessible(new Field[] { field }, true);
                    setFailsafeFieldValue(field, enumClass, null);
                    break;
                }
            }
        }
    
        private static void cleanEnumCache(Class<?> enumClass) throws NoSuchFieldException, IllegalAccessException {
            blankField(enumClass, "enumConstantDirectory"); // Sun (Oracle?!?) JDK 1.5/6
            blankField(enumClass, "enumConstants"); // IBM JDK
        }
    
        public static void main(String[] args) throws Exception {
            addField("com.ctrip.framework.apollo.core.enums.Env", new String[] { "mj1", "mj2" });
    
            Gson gson = new Gson();
            System.out.println(Env.valueOf("MJ1"));
            System.out.println(gson.toJson(Env.values()));
            System.out.println(gson.toJson(Env.valueOf("MJ1")));
            System.out.println(gson.toJson(Env.valueOf("MJ2")));
    
            //        addEnum(Env.class, "testmj", new Class<?>[]{}, new Object[]{});
            //        for(Env codeInfo:Env.values()){
            //            System.out.println(codeInfo.toString());
            //        }
            //        String test="{\"test1\":\"123\",\"test2\":\"456\"}";
            //        Gson gson = new Gson();
            //        Map<String,String> map = gson.fromJson(test, Map.class);
            //        System.out.println(gson.toJson(Env.valueOf("testmj")));
    
        }
    }
    
    
    展开全文
  • java 通过反射获取枚举类,及枚举类的枚举枚举实例名。本项目为普通java项目
  • Java1.5提供了关键字enum,能够通过该关键字方便得定义自己须要的枚举类型,比方  enum Season {  SPRING, SUMMER, AUTUMN, WINTER  }  定义了一个季节枚举类型。  在本例中,对于Season.SPRING这个...
  • Genum是从YAML数组生成Java枚举类文件的代码生成器。 您可以在服务器端和客户端应用程序之间共享定义! 例如,这是一个以YAML格式编写的数组。 - Tokyo - NewYork - London - Beijing - Paris - Roma Genum将其...
  • JAVA动态增加枚举

    千次阅读 2018-02-10 07:58:45
    在项目中,会存在很多枚举,比如下面颜色和水果的枚举,COLOR[RED(1),GREEN(2),BLUE(3)],FRUIT[APPLE(4),BANANA(5),ORANGE(6)],但是问题是,如果要增加枚举类型,就会涉及修改代码的问题,一个比较常见的例子是,...

    前言

    在项目中,会存在很多枚举,比如下面颜色和水果的枚举,COLOR[RED(1),GREEN(2),BLUE(3)],FRUIT[APPLE(4),BANANA(5),ORANGE(6)],但是问题是,如果要增加枚举类型,就会涉及修改代码的问题,一个比较常见的例子是,枚举生成一个列表,供前台选择,如果增加类型,那么前后台都需要进行修改。
    一个思路,是将枚举项保存在数据库里,项目启动或定时刷新枚举项。在项目中,只定义枚举类型,比如

    public enum COLOR{}
    public enum FRUIT{}

    在接口中,使用COLOR.valueOf()就可以获取枚举,并传入后面的处理层了。为什么要使用枚举呢?类型安全么,只要可以获取枚举,就说明前台传的值是正确的,即进行了范围校验。

    代码

    代码是参考了一篇文章https://www.niceideas.ch/roll...
    有兴趣的可以看一下。他的例子,是在一个数据库表里面有一张类似业务流水表,上面有一个CODE字段,代码了对记录的不同处理,CODE很多,他不想手写大量的if...else语句,想转成enum进行处理(这个我还没有相同,动态的enum也没办法直接在代码上switch case,那么是不是他在生成的枚举上,包含了调用的方法)。
    下面是在他代码之上,进行了些许的修改,便于适应我自己的业务场景。

    public enum CodeInfoEnum {
        LOCK(1L,1L,"LOCK_TYPE","LOCK"),UNLOCK(1L,2L,"LOCK_TYPE","LOCK");
        public Long classId;
        public Long infoId;
        public String classCode;
        public String infoCode;
        CodeInfoEnum(Long classId,Long infoId,String classCode,String infoCode){
            this.classId = classId;
            this.infoId = infoId;
            this.classCode = classCode;
            this.infoCode = infoCode;
        }
        public static CodeInfoEnum getByInfoId(Long infoId){
            return CodeInfoEnum.valueOf(infoId+"");
        }
        public static List<CodeInfoEnum> getByClassId(Long classId){
            return Arrays.stream(CodeInfoEnum.values()).filter(item->item.classId.equals(classId)).collect(Collectors.toList());
        }
        public static CodeInfoEnum getByClassCodeAndInfoCode(String classCode,String infoCode){
            Optional<CodeInfoEnum> opt = Arrays.stream(CodeInfoEnum.values()).filter(item->item.classCode.equals(classCode)&&item.infoCode.equals(infoCode)).findFirst();
            return opt.orElse(null);
        }
    
        @Override
        public String toString() {
            return "CodeInfoEnum{" +
                    "classId=" + classId +
                    ", infoId=" + infoId +
                    ", classCode='" + classCode + '\'' +
                    ", infoCode='" + infoCode + '\'' +
                    '}';
        }
    }
    public class DynamicEnumTest {
        private static ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
        private static void setFailsafeFieldValue(Field field, Object target, Object value) throws NoSuchFieldException,
                IllegalAccessException {
    
            // let's make the field accessible
            field.setAccessible(true);
            // next we change the modifier in the Field instance to
            // not be final anymore, thus tricking reflection into
            // letting us modify the static final field
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            int modifiers = modifiersField.getInt(field);
    
            // blank out the final bit in the modifiers int
            modifiers &= ~Modifier.FINAL;
            modifiersField.setInt(field, modifiers);
    
            FieldAccessor fa = reflectionFactory.newFieldAccessor(field, false);
            fa.set(target, value);
        }
        private static void blankField(Class<?> enumClass, String fieldName) throws NoSuchFieldException,
                IllegalAccessException {
            for (Field field : Class.class.getDeclaredFields()) {
                if (field.getName().contains(fieldName)) {
                    AccessibleObject.setAccessible(new Field[] { field }, true);
                    setFailsafeFieldValue(field, enumClass, null);
                    break;
                }
            }
        }
    
        private static void cleanEnumCache(Class<?> enumClass) throws NoSuchFieldException, IllegalAccessException {
            blankField(enumClass, "enumConstantDirectory"); // Sun (Oracle?!?) JDK 1.5/6
            blankField(enumClass, "enumConstants"); // IBM JDK
        }
        private static ConstructorAccessor getConstructorAccessor(Class<?> enumClass, Class<?>[] additionalParameterTypes)
                throws NoSuchMethodException {
            Class<?>[] parameterTypes = new Class[additionalParameterTypes.length + 2];
            parameterTypes[0] = String.class;
            parameterTypes[1] = int.class;
            System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length);
            return reflectionFactory.newConstructorAccessor(enumClass.getDeclaredConstructor(parameterTypes));
        }
    
        private static Object makeEnum(Class<?> enumClass, String value, int ordinal, Class<?>[] additionalTypes,
                                       Object[] additionalValues) throws Exception {
            Object[] parms = new Object[additionalValues.length + 2];
            parms[0] = value;
            parms[1] = Integer.valueOf(ordinal);
            System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length);
            return enumClass.cast(getConstructorAccessor(enumClass, additionalTypes).newInstance(parms));
        }
    
        /**
         * Add an enum instance to the enum class given as argument
         *
         * @param <T> the type of the enum (implicit)
         * @param enumType the class of the enum to be modified
         * @param enumName the name of the new enum instance to be added to the class.
         */
        @SuppressWarnings("unchecked")
        public static <T extends Enum<?>> void addEnum(Class<T> enumType, String enumName,Class<?>[] paramClass,Object[] paramValue) {
    
            // 0. Sanity checks
            if (!Enum.class.isAssignableFrom(enumType)) {
                throw new RuntimeException("class " + enumType + " is not an instance of Enum");
            }
    
            // 1. Lookup "$VALUES" holder in enum class and get previous enum instances
            Field valuesField = null;
            Field[] fields = CodeInfoEnum.class.getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().contains("$VALUES")) {
                    valuesField = field;
                    break;
                }
            }
            AccessibleObject.setAccessible(new Field[] { valuesField }, true);
    
            try {
    
                // 2. Copy it
                T[] previousValues = (T[]) valuesField.get(enumType);
                List<T> values = new ArrayList<T>(Arrays.asList(previousValues));
    
                // 3. build new enum
                T newValue = (T) makeEnum(enumType, // The target enum class
                        enumName, // THE NEW ENUM INSTANCE TO BE DYNAMICALLY ADDED
                        values.size(),
                        //new Class<?>[] {}, // could be used to pass values to the enum constuctor if needed
                        paramClass,
                        //new Object[] {}
                        paramValue
                ); // could be used to pass values to the enum constuctor if needed
    
                // 4. add new value
                values.add(newValue);
                Object object=values.toArray((T[]) Array.newInstance(enumType, 0));
                // 5. Set new values field
                setFailsafeFieldValue(valuesField, null, object);
    
                // 6. Clean enum cache
                cleanEnumCache(enumType);
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    
        public static void main(String[] args) {
    
            //
            synchronized (CodeInfoEnum.class) {
                addEnum(CodeInfoEnum.class, "3", new Class<?>[]{Long.class, Long.class, String.class, String.class}, new Object[]{2L, 3L, "ActiveStatus", "Active"});
                addEnum(CodeInfoEnum.class, "4", new Class<?>[]{Long.class, Long.class, String.class, String.class}, new Object[]{2L, 4L, "ActiveStatus", "Inactive"});
                addEnum(CodeInfoEnum.class, "5", new Class<?>[]{Long.class, Long.class, String.class, String.class}, new Object[]{3L, 5L, "Optype", "OP1"});
                addEnum(CodeInfoEnum.class, "6", new Class<?>[]{Long.class, Long.class, String.class, String.class}, new Object[]{3L, 6L, "Optype", "OP2"});
                addEnum(CodeInfoEnum.class, "7", new Class<?>[]{Long.class, Long.class, String.class, String.class}, new Object[]{3L, 7L, "Optype", "OP3"});
                addEnum(CodeInfoEnum.class, "8", new Class<?>[]{Long.class, Long.class, String.class, String.class}, new Object[]{3L, 8L, "Optype", "OP4"});
            }
            CodeInfoEnum codeInfoEnum =CodeInfoEnum.valueOf("5");
            System.out.println(codeInfoEnum);
            // Run a few tests just to show it works OK.
            System.out.println(Arrays.deepToString(CodeInfoEnum.values()));
            System.out.println("============================打印所有枚举(包括固定的和动态的),可以将数据库中保存的CIC以枚举的形式加载到JVM");
            for(CodeInfoEnum codeInfo:CodeInfoEnum.values()){
                System.out.println(codeInfo.toString());
            }
    
            System.out.println("============================通过codeId找到的枚举,用于PO转VO的处理");
            CodeInfoEnum activeStatus_Active = CodeInfoEnum.getByInfoId(3L);
            System.out.println(activeStatus_Active);
    
            System.out.println("============================通过ClassId找到的枚举列表");
            List<CodeInfoEnum> activeStatusEnumList = CodeInfoEnum.getByClassId(3L);
            for(CodeInfoEnum codeInfo : activeStatusEnumList){
                System.out.println(codeInfo);
            }
    
            System.out.println("============================通过ClassCode和InfoCode获取枚举,用于导入验证CIC合法性");
            CodeInfoEnum toGetActiveStatus_Active = CodeInfoEnum.getByClassCodeAndInfoCode("ActiveStatus","Active");
            System.out.println(toGetActiveStatus_Active);
    
            System.out.println("============================通过ClassCode和InfoCode获取枚举,输入不存在的Code,则返回NULL");
            CodeInfoEnum toGetActiveStatus_miss = CodeInfoEnum.getByClassCodeAndInfoCode("ActiveStatus","MISS");
            System.out.println(toGetActiveStatus_miss);
    
    
        }
    }

    我将项目中所有的枚举,都定义在了CodeInfoEnum中,其中包含两部分,一部分是固定的枚举,我是预定义的,比如记录状态(有效|删除),锁定状态(可用|锁定)等,这些的枚举字面值是英文大写单词;另一部分是动态的,具有比较强的业务含义,比如仓库管理中的库位类型,包装类型这些,这些的枚举字面值是数字,即数据库中的ID。

    在使用的使用,注意:

    1. 在和前台交互的时候,统一使用字面值
    2. 在校验的时候,使用class_code和字面值进行校验。
    3. 在controller进行参数组装的时候,将前台传入的字面值转成CodeInfoEnum
    4. 在持久化的时候使用字面值
    5. 查询的时候,将数据库中的字面值转化为CodeInfoEnum

    上面写的‘使用’,目前还是设想,还没有动手实现。也是我下面准备做的。希望有看到本文的大神,如能提供宝贵意见,将不胜感激。

    展开全文
  • 主要介绍了java枚举是如何保证线程安全的。Java SE5提供了一种新的类型-Java的枚举类型,关键字enum可以将一组具名的的有限集合创建为一种新的类型,而这些具名的可以作为常规的程序组件使用,这是一种非常有用...
  • 主要介绍了Java枚举类型的一种使用方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java 枚举值的用法

    千次阅读 2017-07-24 18:34:02
    Java 枚举值的用法

    嘿,老司机又来了,最近开始新项目,近期更新文章的频率将会很低,这里简单列举java枚举值的用法,希望你能够受用大笑


    java枚举值使用方法一: 基本用法不带构造函数:

    提供思路:

    创建简单枚举值;

    public enum Test {
       Mon,
       Tue,
       Wed;
    }


    创建main方法进行循环遍历;

    public static void main(String[] args) {
        for (Test test: Test.values()) {
         System.out.println("name" + test.name() + "ordinal" + test,ordinal());
       }
    }

    调用枚举值的name() 与 ordinal() 方法;

    参考第二步,至此最简单的已经完成;            


    java枚举值使用方法二: 超越基本用法携带带参的构造函数-----(是不是有点绕口,其实很简单,在基本用法上,声明变量,添加get和set方法,将变量添加到构造函数中,并且重写set方法,这就是思路,看下面具体实例):


    提供思路: 请参考方法一 与 方法二括号中的内容,梳理出完整的思路:

    创建枚举值,携带带参的构造函数;

    public enum Test {
       Mon("星期一"),
       Tue("星期二"),
       Wed("星期三");
      
      //声明变量
       private String testType;
    
       // 带参构造函数
          Test(String testType){
           this.testType = testType;
       }   
    
       重写set 方法:
       for (Test test : Test.values()) {  
                    if (test.getTestType().equals(testType)) {  
                        return test;  
                    }  
                }  
                return null;  
    
       get方法;
    }


    声明一个变量;

    private String testType;

    重写set方法;

     for (Test test : Test.values()) {  
                    if (test.getTestType().equals(testType)) {  
                        return test;  
                    }  
                }  
                return null;  

    创建main方法进行测试

    public static void main(String[] args) {
        for (Test test: Test.values()) {
         System.out.println("name" + test.name() + "name" + "test.getTestType()" + "ordinal" + test,ordinal());
       }
    }

    简单到复杂的一个demo完成,经测试能够正常使用,重点是 思路,思路,思路!!!大笑大笑大笑


    更多文章,请关注 http://blog.csdn.net/qq_37022150


    展开全文
  • 主要介绍了Java枚举类型在switch语句正确使用方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • } //根据传入的type动态获取name public static String getNameByType(String type) { TestEnum [] testEnums = values(); //获取所有枚举集合 for (TestEnum testEnum : testEnums) { if (testEnum.getType()....
    public enum TestEnum {
    
        /**
         * 测试类型
         */
        TEST_A("1", "测试A"),
        TEST_B("2", "测试B"),
        TEST_C("3", "测试C"),
        TEST_D("4", "测试D");
    
        private String type;
        private String name;
    
        TestEnum(String type, String name) {
            this.type = type;
            this.name = name;
        }
    
        public String getType() {
            return type;
        }
    
    
        public String getName() {
            return name;
        }
    
        //根据传入的type动态获取name
        public static String getNameByType(String type) {
            TestEnum [] testEnums = values();    //获取所有枚举集合
            for (TestEnum testEnum : testEnums) {
                if (testEnum.getType().equals(type)) {
                    return testEnum.getName();
                }
            }
            return null;
        }
    }
    
    

     

    展开全文
  • Java根据枚举索引值来获取枚举值 枚举类.class.getEnumConstants()[枚举索引] 例如: BorderStyle.class.getEnumConstants()[Integer.valueOf(borderStyle)];
  • Java 遍历枚举值

    万次阅读 2020-09-19 09:18:46
    Java 遍历枚举值 枚举是Java中数据类型,用于将一组预定义常量赋给变量。本文介绍几种方式遍历枚举值。 1. 定义枚举 首先我们定义枚举,简单示例如下: public enum DaysOfWeekEnum { SUNDAY, MONDAY, TUESDAY, ...
  • 今天小编就为大家分享一篇关于Java中对于双属性枚举的使用案例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • Java动态生成枚举类型

    2020-01-15 11:15:07
    工具类: import sun.reflect.ConstructorAccessor; import sun.reflect.FieldAccessor; import sun.reflect....import java.lang.reflect.AccessibleObject; import java.lang.reflect.Array; impor...
  • java 枚举值如何比较

    2021-01-30 10:18:44
    枚举值可以直接用 == 比较, 因为枚举值是单例的, 相同枚举值, 一定是相同的对象 也可以使用 equals 比较, 枚举类的基类重写了 equals 方法, 内部也是 == 判断的 /** * equals */ @Test public void testEquals...
  • Java –比较枚举值

    千次阅读 2020-06-04 12:15:37
    Java枚举示例 语言.java package com.mkyong.java public enum Language { JAVA, PYTHON, NODE, NET, RUBY } 2.与==比较 将枚举值与==运算符进行比较的示例。 Test.java pa...
  • 主要介绍了java枚举类enum的values()方法的详解的相关资料,希望通过本文大家能够掌握这部分内容,需要的朋友可以参考下
  • 深入理解Java枚举类型(enum)

    万次阅读 多人点赞 2017-05-13 18:27:14
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 关联文章: 深入理解Java类型信息...深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • Java随机获取枚举类的值,获取的枚举值可以根据最大值,最小值来控制 public static <T extends Enum<?>> T randomEnum(Class<T> clazz, Integer min, Integer max) { Random random = new Random(); if (min > ...
  • 有时候,有一些下拉选择器的数据项,我们采取了枚举的方式简单记录,但是里面的东西多,前端不想写死,需要提供接口返回。 示例: 枚举 /** * @Author: JCccc * @Description: * @Date: Create in 10:51 2021...
  • 示例:下面的getName方法 /** * 申请人特殊程序状态 * @author vhukze * @date 2021/2/7 - 9:11 */ @Getter public enum ApplicantSpecialStatusEnum { ... 已完成立案审查_待接收立案通知(4), ...
  • JAVA枚举操作(获取,转map集合)

    千次阅读 2019-05-15 18:24:24
    JAVA枚举相对来说比.NET的枚举功能强大,感觉就像是一种简化版的类对象,可以有构造方法,可以重载,可以继承接口等等,但不能继承类,JAVA枚举在实际开发中应用相当频繁,以下几个封装方法在实际开发中可能用到,...
  • Java枚举详解

    万次阅读 多人点赞 2019-05-12 23:07:44
    枚举是一个被命名的整型常数的集合,用于声明一组带标识符的常数。枚举在曰常生活中很常见,例如一个人的性别只能是“男...而使用 Java 枚举类型 enum 可以更贴近地表示这种常量。 声明枚举 声明枚举时必须使用 enu...
  • 定义枚举 public enum NodeType { /** * 节点类型枚举 */ USER_TASK("userTask", "用户审批节点", UserTask.class); public String type; public String name; public Class<?> clazz; public ...
  • Java根据枚举名使用反射获取枚举值

    千次阅读 2018-12-12 18:36:26
    由于前端需要根据枚举名获取实时获取枚举值,所以通过反射去得到枚举数据. (一) 首先我们新建一个枚举类接口,用于之后反射使用 package com.littlematch.enums.biz; /** * 枚举值接口定义类 */ public interface ...
  • java中常用的枚举方法有values和valueof valueOf方法会把一个String类型的名称转变成枚举项,也就是在枚举项中查找字面值和该参数相等的枚举项。 values是获取所有的枚举项 package HtppClient1.EnumUtil; ...
  • Java枚举类enum介绍

    2020-09-03 19:44:42
    主要介绍了Java枚举类enum介绍,和其它普通类一样,enum同样可以有成员变量、方法、构造器,也可以实现一个或多个接口,需要的朋友可以参考下
  • 动态获取枚举值

    千次阅读 2018-10-11 10:40:31
    问题背景:需要给不同类型的数据添加单位,所以设计了枚举型,根据ID来去字符串表示,以作笔记: //枚举设计  public enum VariableUnits  {  V = 1,  A = 3,  kW = 26,  kWh = 30  } //获取枚举字符串 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,041
精华内容 63,216
关键字:

java枚举动态值

java 订阅