精华内容
下载资源
问答
  • 和枚举类相关的Map类——EnumMap

    千次阅读 2017-04-12 09:47:31
    EnumMap是一个与枚举类一起使用的Map实现,EnumMap中所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。 EnumMap在内部以数组形式保存,所以这种实现形式非常紧凑、高效。 ...

    1 EnumMap类的简介

    • EnumMap是一个与枚举类一起使用的Map实现,EnumMap中所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。
    • EnumMap在内部以数组形式保存,所以这种实现形式非常紧凑、高效。
    • EnumMap根据key的自然顺序(即枚举值在枚举类中的定义顺序)来维护来维护key-value对的次序。当程序通过keySet()、entrySet()、values()等方法来遍历EnumMap时即可看到这种顺序。
    • EnumMap不允许使用null作为key值,但允许使用null作为value。如果试图使用null作为key将抛出NullPointerException异常。如果仅仅只是查询是否包含值为null的key、或者仅仅只是使用删除值为null的key,都不会抛出异常。

    2 代码示例

    import java.util.*;
    
    enum Season
    {
    	SPRING,SUMMER,FALL,WINTER
    }
    public class EnumMapTest
    {
    	public static void main(String[] args)
    	{
    		// 创建EnumMap对象,该EnumMap的所有key都是Season枚举类的枚举值
    		EnumMap enumMap = new EnumMap(Season.class);
    		enumMap.put(Season.SUMMER , "小荷才露尖尖角");
    		enumMap.put(Season.SPRING , "满园春色关不住");
    		System.out.println(enumMap);
    	}
    }

    3 运行结果

    {SPRING=满园春色关不住, SUMMER=小荷才露尖尖角}

    4 代码分析

    上面程序中创建了一个EnumMap类,创建该EnumMap对象时指定它的key只能是Season枚举类的枚举值。如果向该EnumMap中添加两个key-value对后,这两个key-value对将会以Season枚举值的自然顺序排序。

    展开全文
  • java 读取枚举类的值转成list和map

    千次阅读 2019-06-13 15:45:44
    首先Enum: public enum RuleTypeEnum { //officeClerk,estimator,administrator,personnel都是国际化的key值 officeClerk("officeClerk",99), estimator("estimator",1), administrator("administr...

    首先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枚举类使用总结

    2018-08-02 17:00:00
    Java枚举类使用总结 1、枚举类使用情况一: 1 package com.bie.util; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 6 /** 7 * 8 * @author biehl 9 * 1...

    Java枚举类使用和总结

    1、枚举类使用情况一:

      1 package com.bie.util;
      2 
      3 import java.util.HashMap;
      4 import java.util.Map;
      5 
      6 /**
      7  * 
      8  * @author biehl
      9  *
     10  * @date 2018年8月2日上午9:18:16
     11  * 
     12  * @Notes 枚举,返回登陆结果案例
     13  *
     14  */
     15 public enum LoginResult {
     16 
     17     LOGIN_SUCCESS(0, "登陆成功"),
     18     LOGIN_FAILED(1, "登陆失败"),
     19     LOGIN_ACCOUNT_NO(2, "登陆账号不存在"),
     20     LOGIN_ACCOUNT_ERROR(3, "登陆账号错误"),
     21     LOGIN_PASSWORD_ERROR(4, "登陆密码错误");
     22     
     23     private int type;//类型
     24     private String desc;//描述
     25     //构造方法,决定了上面枚举的字段
     26     private LoginResult(int type, String desc) {
     27         this.type = type;
     28         this.desc = desc;
     29     }
     30     
     31     public int getType() {
     32         return type;
     33     }
     34     public void setType(int type) {
     35         this.type = type;
     36     }
     37     public String getDesc() {
     38         return desc;
     39     }
     40     public void setDesc(String desc) {
     41         this.desc = desc;
     42     }
     43     
     44     
     45     /**
     46      * 根据type获取到描述desc
     47      * @param type
     48      * @return
     49      */
     50     public static String getResultDescByType(int type){
     51         //获取到枚举
     52         LoginResult[] values = LoginResult.values();
     53         //加强for循环进行遍历操作
     54         for(LoginResult lr : values){
     55             //如果遍历获取的type和参数type一致
     56             if(lr.getType() == type){
     57                 //返回type对象的desc
     58                 return lr.getDesc();
     59             }
     60         }
     61         return null;
     62     }
     63     
     64     /**
     65      * 根据type获取到对应的enum
     66      * @param type
     67      * @return
     68      */
     69     public static LoginResult getResultEnumByType(int type){
     70         //获取到枚举
     71         LoginResult[] values = LoginResult.values();
     72         for(LoginResult lr : values){
     73             if(lr.getType() == type){
     74                 return lr;
     75             }
     76         }
     77         return null;
     78     }
     79     
     80     
     81     /**
     82      * getChoiceMap
     83      * @return
     84      */
     85     public static Map<Integer, String> getChoiceMap(){
     86         Map<Integer, String> map = new HashMap<Integer, String>();
     87         for(LoginResult lr : LoginResult.values()){
     88             map.put(lr.getType(), lr.getDesc());
     89         }
     90         return map;
     91     }
     92     
     93     public static void main(String[] args) {
     94         //根据type获取到对应的desc
     95         //运行结果:登陆成功
     96         //System.out.println(LoginResult.getResultDescByType(0));
     97         
     98         //可以根据type获取到对应的enum枚举
     99         //运行结果:LOGIN_SUCCESS
    100         System.out.println(LoginResult.getResultEnumByType(0));
    101         
    102         //将type和desc封装到map集合里面
    103         //运行效果:{0=登陆成功, 1=登陆失败, 2=登陆账号不存在, 3=登陆账号错误, 4=登陆密码错误}
    104         //System.out.println(LoginResult.getChoiceMap());
    105     }
    106     
    107 }

    2、枚举类使用情况二:

     1 package com.bie.util;
     2 
     3 /**
     4  * 
     5  * @author biehl
     6  *
     7  * @date 2018年8月2日下午3:38:28
     8  * 
     9  * @Notes REGISTER("注册"),这种类型的枚举可以使用在调用此枚举类然后使用switch来匹配到对应的方法
    10  *
    11  */
    12 public enum OperatorType {
    13 
    14     REGISTER("注册"),
    15     LOGIN("登陆"),
    16     INSERT("增加"),
    17     DELETE("删除"),
    18     UPDATE("修改"),
    19     SELECT("查询"),
    20     ;
    21     
    22     //构造方法
    23     private OperatorType(String desc){
    24         this.desc = desc;
    25     }
    26     
    27     private String desc;//描述
    28     
    29     public String getDesc() {
    30         return desc;
    31     }
    32     public void setDesc(String desc) {
    33         this.desc = desc;
    34     }
    35     
    36     /**
    37      * 根据desc获取到enum
    38      * @param desc
    39      * @return
    40      */
    41     public static OperatorType getResultEnumByDesc(String desc){
    42         OperatorType[] values = OperatorType.values();
    43         for(OperatorType ot : values){
    44             if(ot.getDesc() == desc){
    45                 return ot;
    46             }
    47         }
    48         return null;
    49     }
    50     
    51     
    52     public static void main(String[] args) {
    53         //根据desc获取到enum
    54         //结果:DELETE
    55         System.out.println(OperatorType.getResultEnumByDesc("删除"));
    56         
    57     }
    58     
    59 }

    3、枚举类使用情况三:

      1 package com.bie.util;
      2 
      3 import java.util.HashMap;
      4 import java.util.Map;
      5 
      6 public enum GroupEnum {
      7 
      8     GROUP_ONE(0,"group_one","一组"),
      9     GROUP_TWO(1,"group_two","二组"),
     10     GROUP_THREE(2,"group_three","三组"),
     11     GROUP_FOUR(3,"group_four","四组"),
     12     GROUP_FIVE(4,"group_five","五组"),
     13     GROUP_SIX(5,"group_six","六组"),
     14     GROUP_SENVEN(6,"group_senven","七组"),
     15     ;
     16     
     17     private GroupEnum(int id, String type, String desc) {
     18         this.id = id;
     19         this.type = type;
     20         this.desc = desc;
     21     }
     22     
     23     private int id;
     24     private String type;
     25     private String desc;
     26     
     27     public int getId() {
     28         return id;
     29     }
     30     public void setId(int id) {
     31         this.id = id;
     32     }
     33     public String getType() {
     34         return type;
     35     }
     36     public void setType(String type) {
     37         this.type = type;
     38     }
     39     public String getDesc() {
     40         return desc;
     41     }
     42     public void setDesc(String desc) {
     43         this.desc = desc;
     44     }
     45     
     46     /**
     47      * 根据type获取到对应的enum
     48      * @param type
     49      * @return
     50      */
     51     public static GroupEnum getResultEnumByType(String type){
     52         GroupEnum[] values = GroupEnum.values();
     53         for(GroupEnum ge : values){
     54             if(ge.getType() == type){
     55                 return ge;
     56             }
     57         }
     58         return null;
     59     }
     60     
     61     /**
     62      * 根据type获取到对应的desc
     63      * @param type
     64      * @return
     65      */
     66     public static String getResltDescByType(String type){
     67         GroupEnum[] values = GroupEnum.values();
     68         for(GroupEnum ge : values){
     69             if(ge.getType() == type){
     70                 return ge.getDesc();
     71             }
     72         }
     73         return null;
     74     }
     75     
     76     /**
     77      * 获取到封装的type和desc
     78      * @return
     79      */
     80     public static Map<String, String> getChoiceMap(){
     81         Map<String, String> map = new HashMap<String, String>();
     82         for(GroupEnum ge : GroupEnum.values()){
     83             map.put(ge.getType(), ge.getDesc());
     84         }
     85         return map;
     86     }
     87     
     88     public static void main(String[] args) {
     89         //根据参数2,type获取到对应的enum
     90         //运行结果:GROUP_ONE
     91         //System.out.println(GroupEnum.getResultEnumByType("group_one"));
     92         
     93         //根据type获取到对应的desc
     94         //运行结果:一组
     95         //System.out.println(GroupEnum.getResltDescByType("group_one"));
     96         
     97         //获取到封装好的type和desc
     98         //运行结果:{group_senven=七组, group_six=六组, group_one=一组, group_five=五组, group_three=三组, group_two=二组, group_four=四组}
     99         System.out.println(GroupEnum.getChoiceMap());
    100     }
    101     
    102 }

     

    待续.......

    posted @ 2018-08-02 17:00 别先生 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • 枚举规范写法 如下枚举,粘贴整个枚举,直接修改字段,其他方法不用修改。 import java.util.ArrayList; import java.util.HashMap;...功能说明:订单状态枚举类 @author Peter 中技同创(www.ditiy.com) */ public en...

    枚举规范写法

    如下枚举,粘贴整个枚举,直接修改字段,其他方法不用修改。

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;

    /**

    /**

    • 交易成功上送中、交易成功、交易失败
      */
      SUCCESS(“交易成功”),

    /**

    • 交易失败
      */
      FAILED(“交易失败”),

    /**

    • 等待支付
      */
      WAITING_PAYMENT(“上送中”),
      EXCEPTION(“未支付”);

    /** 描述 */
    private String desc;

    private TradeStatusEnum(String desc) {
    this.desc = desc;
    }

    public String getDesc() {
    return desc;
    }

    public void setDesc(String desc) {
    this.desc = desc;
    }

    //方便根据名称获取描述比如:TradeStatusEnum.toMap().get("FAILED"get(“desc”).toString()

    public static Map<String, Map<String, Object>> toMap() {
    TradeStatusEnum[] ary = TradeStatusEnum.values();
    Map<String, Map<String, Object>> enumMap = new HashMap<String, Map<String, Object>>();
    for (int num = 0; num < ary.length; num++) {
    Map<String, Object> map = new HashMap<String, Object>();
    String key = ary[num].name();
    map.put(“desc”, ary[num].getDesc());
    enumMap.put(key, map);
    }
    return enumMap;
    }

    //获取所有属性用list返回

    @SuppressWarnings({ “rawtypes”, “unchecked” })
    public static List toList() {
    TradeStatusEnum[] ary = TradeStatusEnum.values();
    List list = new ArrayList();
    for (int i = 0; i < ary.length; i++) {
    Map<String, String> map = new HashMap<String, String>();
    map.put(“desc”, ary[i].getDesc());
    map.put(“name”, ary[i].name());
    list.add(map);
    }
    return list;
    }

    public static TradeStatusEnum getEnum(String name) {
    TradeStatusEnum[] arry = TradeStatusEnum.values();
    for (int i = 0; i < arry.length; i++) {
    if (arry[i].name().equalsIgnoreCase(name)) {
    return arry[i];
    }
    }
    return null;
    }

    /**

    • 取枚举的json字符串
    • @return
      */
      public static String getJsonStr() {
      TradeStatusEnum[] enums = TradeStatusEnum.values();
      StringBuffer jsonStr = new StringBuffer("[");
      for (TradeStatusEnum senum : enums) {
      if (!"[".equals(jsonStr.toString())) {
      jsonStr.append(",");
      }
      jsonStr.append("{id:’").append(senum).append("’,desc:’").append(senum.getDesc()).append("’}");
      }
      jsonStr.append("]");
      return jsonStr.toString();
      }
      }
    展开全文
  • 在之前的文章中说了,集合的listset,还剩下一个Map,现在我就来介绍一下Map集合 Map接口 |—–HashMap:Map的主要实现 |—–LinkedHashMap:使用链表维护添加进Map中的顺序。故遍历Map时,是按添加的顺序...
  • 32、枚举类的属性、方法、构造器 33、实现接口的枚举类 34、包含抽象方法的抽象枚举类 35、类委托 36、属性委托 37、延迟属性 38、属性监听 39、使用Map存储属性值 40、局部属性委托 41、委托工厂 ...
  • java-enum枚举类

    2018-06-19 10:45:00
    枚举类 默认 隐式继承java.lang.Enum抽象类 java.lang.Enum是所有java语言枚举类型的公共基类。 *关于枚举的更多信息,包括对 *由编译器合成的隐式声明 注意,当使用枚举类型作为集合的类型时 *或作为Map中键的...
  • 枚举转JSON或map或对象List

    千次阅读 2021-01-21 16:42:08
    记录一下转换过程遇到的问题,及解决办法。...枚举类 public enum TypeEnum { QUESTION(1, "问题"), ANSWER(2, "回答"), COMMENT(3, "评论"), NICK(4, "昵称"); private final int value;
  • 和枚举相关的集合

    2018-08-01 18:27:58
    在JDK 1.5的java.util 程序包中提供两个新的集合操作: EnumMap EnumSet,这两个枚举类型的结合应用可使以前非常繁琐的程序变得简单方便。 EnumSet提供了java.util.Set接口的一个特殊实现,而EnumMap...
  • 除了普通的(接口)以外,在图里可以定义一些特殊的元素,比较常见的是枚举类型、自定义类型,它们对于一个完整可用的模型也是必不可 少的,这篇帖子主要介绍EMF里它们的使用方法。另外,由于EMF对Map的支持比较...
  • 在Apache的不同枚举类中,针对Apache中枚举的一些获取枚举类型获取枚举集合或者Map的方法,不幸的是,Java的限制,要求这些被编码在每个子所示。 一种方案在每一个中写这些方法。 一种实现方案就是在使用时调用...
  • Java Set接口 Map枚举

    2019-04-29 20:31:01
    文章目录Set接口HashSetTreeSetLinkeHashSetMap集合枚举 Set接口 概述 一个不包含重复元素的 collection。更确切地讲,set 不包含满足 e1.equals(e2) 的元素对 e1 e2,并且最多包含一个 null 元素 特点 Set...
  • Java.util中添加了两个新,EnumMapEnumSet来支持枚举类型。 5.EnumMap:枚举类型实例到值的映射 Map是Java中的一个,EnumMap是Map的子类。Map(映射)是一个二元组的集合,它中的每个元素都是由<Key,...
  • java.lang:编写java程序时最广泛使用的包,自动导入到所有的程序中,包含了java程序的基础类和接口。包装类、Math类String类等常用的类都包含在此类中,java.lang包还提供了用于管理类的动态加载、外部进程创建、...
  • JeecgBoot initQueryWrapper和枚举

    千次阅读 2020-04-10 19:36:35
    多看看jeecg这里的源码, 可能有更好的...现在, notice 有一个内部的枚举类(枚举类在代码层debug的有利, 所以我们这里才用了enum, 而不是数据库字典的方式) 问题来了, initQueryWrapper不支持enum, 怎么办? 弃用ini...
  • 泛型和枚举

    2019-05-16 16:35:18
    在泛型中写的是一个对象,不能是基本的数据类型(写起对应的包装) *List遍历方式:for循环、迭代器、增强for *set遍历方式:迭代器、增强for(元素无序、不能重复出现) *在map上使用泛型 Map(key,value...
  • 最近需要一个能够在字符串和枚举值之间互相转换的功能,因为C++没有对枚举值进行遍历、反射之的操作,不像Java那样可以轻松搞定。网上找到一些代码感觉用起来有点不爽,于是研究一番后,写了一个工具。 闲话不多...
  • 点评原型到几种方法:1.函数指针类型2.工厂模型3.宏的方法使用4.静态函数的使用5.静态成员变量的使用 静态成员变量的定义后,仍然需要在cpp中引用之。...6.map方法的使用//stdafx.h-------------------------------
  • 1.导入pom文件 ,版本号自定 <!--mapStruct依赖--> <dependency> <groupId>org.mapstruct</groupId> <artifactId>mapstruct-jdk8</artifactId>...
  • 我们在用程序解决问题时候,经常会碰到这样一问题:“查找一个元素是不是存在”,比如一个整数是不是在一个整数集合中。 要解决这样的问题,哈希表是一个非常好用的工具。而且更方便的是,C++的STL已经帮我们把...
  • java 枚举

    千次阅读 2013-06-03 18:05:47
    个人理解枚举类是预初始化了指定实例的java类,枚举列有很多有趣的用法,伴随EnumSet(高性能Set)EnumMap(高性能Map)的加入,枚举类变得越来越有意思,如果我们有Set集合或Map集合key有了枚举类的特征(稳定、...
  • 若是用手动编写的话,不要说手会酸了,有可能眼还会瞎(眼睛手指的噩梦。。。)。后来自己就试着用代码来生成代码了 package com.lbl.standarcode; import java.util.HashMap; import java.util.Map; public c
  • AX 2009 Map类

    2019-10-01 21:40:06
    Map类 Map同时保存一个索引键(Keys)一个值(Values),键值都可以是指定的数据类型。 键不能重复,但值可以重复。所以,多个键可以指向同一个值,但是一个键只能有一个值。 当插入的键已经存在时,Map会使用新...
  • 上面代码可能我们不知想要将A0当作常量使用获取“未付款”,有的时候,可能我们还需要通过枚举实现map的类似功能,如我们通过传入一个参数“A0”去得到“未付款”这个字符串,其实方法很简单,只要一行代码便可以...
  • 说明:普通的Map和Set也可以用来放枚举类型,但是用这两个会更加的高效节省空间。这里两个都不是线程安全的。   EnumSet:EnumSet普通的Set差不多,但是他是专门用来存放枚举类型的数据的(枚举类型都是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 419
精华内容 167
关键字:

枚举类和map