码迷,mamicode.com
首页 > 编程语言 > 详细

Java集合框架(五)—— Map、HashMap、Hashtable、Properties、SortedMap、TreeMap、WeakHashMap、IdentityHashMap、EnumMap

时间:2018-02-10 13:06:36      阅读:167      评论:0      收藏:0      [点我收藏+]

标签:封装   sort   tac   als   引用类型   集合框架   查找   system   相同   

  • Map

  Map用于保存具有映射关系的数据,因此Map集合里保存着两组值,一组值用于保存Map里的key,另一组值用于保存Map里的value,key和value都可以是任何引用类型的数据。Map的key不容许重复即同一个Map对象的任何两个key通过equals方法比较总是返回false。

  key和value之间存在单向一对一关系,即通过指定的key,总能找到唯一的、确定的value。从Map中取出数据时,只要给出指定的key,就可以取出对应的value。

  如果把Map里的所有key放在一起看,它们就是一个Set集合,实际上Map确实包含一个keySet()方法,用于返回Map所有key组成的Set集合。如下:

public class Test {
    public static void main(String[] args){
        Map<String, String> mapVal = new HashMap<String, String>();
        mapVal.put("spring", "春");
        mapVal.put("summer", "夏");
        mapVal.put("autumn", "秋");
        mapVal.put("winter", "冬");
        //获取mapVal集合的所有key值
        Set<String> set = mapVal.keySet();
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String season = it.next();
            System.out.println(season);
        }
    }
}

  不仅如此,Map里key集合和Set集合里元素的存储形式也很像,Map子类和Set子类在名字上也惊人的相似:如Set接口下有HashSet、LinkedHashSet、SortedSet(接口)、TreeSet、EnumSet等实现类和子接口,而Map接口下则有HashMap、LinkedHashMap、SortedMap(接口)、TreeMap、EnumMap等实现类和子接口。正如它们名字所暗示的,Map的这些实现类和子接口中key集存储形式和对应Set集合中元素的存储形式完全相同。

  如果把Map所有value放在一起看,它们又非常类似于一个List:元素与元素之间可以重复,每个元素可以根据索引来查找,只是map中的索引不再使用整数值,而是以另一个对象做为索引。如果需要从List集合中取元素,需要提供该元素的数字索引;如果需要从Map中取出元素,需要提供该元素的key索引。因此,Map有时也被称为字典,或关联数组。Map接口中定义了如下常用方法:

  1. void clear();  //删除该Map对象中所有key-value对。
  2. boolean containsKey(Object key);        //查询Map中是否包含指定key,如果包含则返回true。
  3. boolean containsValue(Object value);   //查询Map中是否包含一个或多个value,如果包含则返回true。
  4. Set entrySet();        //返回Map中所包含的key-value对所组成的Set集合,每个集合元素都是Map.Entry(Entry是Map的内部类)对象。
  5. Object get(Object key);        //返回指定key所对应的value,如果此Map不包含该key,则返回null。
  6. boolean isEmpty();            //查询该Map集合是否为空(即不包含任何key-value对),如果为空则返回true。
  7. Set keySet();      //返回该Map中所有key所组成的Set集合。
  8. Object put(Object key, Object value);       //添加一个key-value对,如果当前Map中已有一个与key相等的key-value对,则新的key-value对会覆盖原来的key-value对。
  9. void putAll(Map m);        //将指定Map中的key-value对复制到本Map中。
  10. Object remove(Object key);        //删除指定key所对应的key-value对,返回被删除key所关联的value,如果key不存在,返回nul
  11. int size();            //返回该Map里的key-value对的个数。
  12. Collection values();     //返回该Map里所有value组成的Collection。

  Map中包含一个内部类:Entry该类封装了一个key-value对,Entry包含三个方法:

  1. Object  getKey();  //返回该Entry里包含的key值。
  2. Object  getValue();   //返回该Entry里包含的value值。
  3. Object  setValue(V value);  //设置该Entry里包含的value值,并返回新设置的value值。

 我们可以把Map理解成一个特殊的Set,只是该Set里包含的集合元素是Entry对象,而不是普通对象。

如下为Entry示例:

public class Test {
    public static void main(String[] args){
        Map<String, String> mapVal = new HashMap<String, String>();
        mapVal.put("spring", "春");
        mapVal.put("summer", "夏");
        mapVal.put("autumn", "秋");
        mapVal.put("winter", "冬");
        Set<Entry<String, String>> entrySet = mapVal.entrySet();
        Iterator<Entry<String, String>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Entry<String, String> next = iterator.next();
            String key = next.getKey();
            String value = next.getValue();
            System.out.println("key:"+ key +"-------value:" + value);
        }
    }
}
  •  HashMap和Hashtable实现类

  HashMap和Hashtable都是Map接口的典型实现类,他们之间的关系完全类似于ArrayList和Vector的关系Hashtable是一个古老的Map实现类,它从JDK1.0起就已经出现了,当它出现时,Java没有提供Map接口,所以它包含了两个繁琐的方法:elements()(类似于Map接口定义的values()方法)和keys(类似于Map接口定义的keySet()方法),现在很少使用这两个方法。

  HashMap和Hashtable的两点典型区别:

  Hashtable是一个线程安全的Map实现,但HashMap线程不安全的实现,所以HashMap比Hashtable性能要高一点;但如果有多条线程访问同一个Map对象时,使用Hashtable实现类会更好。

  Hashtable不容许使用null作为key和value,如果试图把null放进Hashtable中,将会引发NullPointerException异常;但HashMap可以使用null做为key和value。

  注意:与Vector类似,尽量少用Hashtable实现类,即使需要创建线程安全的Map实现类,也可以通过Collections工具类把HashMap变成线程安全的,无须使用Hashtable实现类。

  为了成功地在HashMap、Hashtable中存储、获取对象,用作key的对象必须实现hashCode方法和equals方法。

  与HashSet不能保证元素的顺序一样,HashMap和Hashtable也不能保证key-value对的顺序。类似于HashSet的是,HashMap、Hashtable判断两个key相等的标准也是:两个key通过equals方法比较返回true,两个key的hashCode值也相等。

  除此之外,HashMap、Hashtable中还包含一个containsValue方法用于判断是否包含指定的value,那么HashMap、Hashtable如何判断两个value相等呢?HashMap、Hashtable判断两个value相等的标准更简单:只要两个对象通过equals比较返回true即可。 

  • LinkedHashMap类  

  HashMap有一个子类:LinkedHashMap;LinkedHashMap也使用双向链表来维护key-value对的次序,该链表定义了迭代顺序,该迭代顺序与key-value对的插入顺序保持一致。LinkedHashMap可以避免需要对HashMap、Hashtable里的key-value对进行排序(只要插入key-value对时保持顺序即可)。同时又避免使用TreeMap所增加的成本。

  LinkedHashMap需要维护元素的插入顺序,因此性能略低于HashMap的性能,但在迭代访问Map里的全部元素时将有很好的性能,因为它以链表来维护内部顺序。

public class Test {
    public static void main(String[] args){
        LinkedHashMap<String, String> mapVal = new LinkedHashMap<String, String>();
        mapVal.put("spring", "春");
        mapVal.put("summer", "夏");
        mapVal.put("autumn", "秋");
        mapVal.put("winter", "冬");
        System.out.println(mapVal);
        for(String str : mapVal.keySet()){
            System.out.println("key:" + str);
            System.out.println("value:" + mapVal.get(str));
        }
    }
}
  • Properties类

  Properties类是Hashtable类的子类,正如它的名字所暗示的,该文件在处理属性文件。Properties类可以把Map对象和属性文件关联起来,从而可以把Map对象中的key-value对写入属性文件,也可以把属性文件中的属性名=属性值加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型,所以Properties里的key、value都是字符串类型,该类提供了如下三个方法来修改Properties里的key、value值。

  1. String  getProperty(String key);   //获取properties中指定属性名对应的属性值,类似于Map的get(Object key)方法。
  2. String  getProperty(String key, String defaultValue);    //该方法与前一个方法基本相似,该方法多个功能,如果Properties中不存在指定key时,该方法返回默认值。
  3. Object setProperty(String  key, String value);    //设置属性值,类似Hashtable的put方法。
  4. void load(InputStream inStream);      //从属性文件(以输出流表示)中加载属性名=属性值,把加载到的属性名=属性值对追加到Properties里(由于Properties是Hashtable的之类,它不保证key-value对之间的次序)。
  5. void store(OutputStream out, String comments);    //将Properties中的key-value对写入指定属性文件(以输出流表示),comments是要写的注解。

  如下代码所示:

public class Test {
    public static void main(String[] args){
        Properties readProperties = new Properties();  //用来写的Properties对象
        readProperties.setProperty("username", "zhangsan");
        readProperties.setProperty("password", "123456");
        Properties writeProperties = new Properties(); //用来读的Properties对象
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //1.1通过类装载器获取要存储的路径
            String path = Test.class.getResource("/").getPath();
                path = path +  "config.properties";
            System.out.println(path);
            fileOutputStream = new FileOutputStream(new File(path));
            //1.2将配置文件信息写到硬盘上
            readProperties.store(fileOutputStream, "This is config with database!");
            
            //2.1读取硬盘上的配置文件
            fileInputStream = new FileInputStream(new File(path));
            writeProperties.load(fileInputStream);
            String username = writeProperties.getProperty("username");
            String username2 = writeProperties.getProperty("username2" , "没有找到username2的key");
            //打印结果"sername:zhangsan"
            System.out.println("username:" + username);
            //打印结果"username2:没有找到username2的key"
            System.out.println("username2:" + username2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fileOutputStream != null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}
  •  SortedMap接口和TreeMap实现类

  正如Set接口派生出了SortedSet子接口,SortedSet接口有一个TreeSet实现类,Map接口也派生了一个SortedMap子接口,SortedMap也有一个TreeMap实现类。

  与TreeSet类似的是,TreeMap也是基于红黑树对TreeMap中所有key进行排序,从而保证TreeMap中所有key-value对处于有序状态。TreeMap也有两种排序方式:

    自然排序:TreeMap的所有key必须实现那Comparable接口,而且所有key应该是同一个类的对象,否则将会抛出ClassCaseException。

    定制排序:创建TreeMap时,传入一个Comparator对象,该对象负责对TreeMap中所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。

  *可以参考TreeSet的代码演示。

  • WeakHashMap实现类

  WeakHashMap与HashMap的用法基本相似。但与HashMap的区别在于,HashMap的key保留对象的强引用,这意味着只要该HashMap对象不被销毁,该HashMap对象所有key所引用的对象不会被垃圾回收,HashMap也不会自动删除这些key所对应的key-value对象;WeakHashMap的key只保留对实际对象的弱引用,这意味着当垃圾回收了该key所对应的实际对象后,WeakHashMap会自动删除该key对应的key-value对。

public class Test {
    public static void main(String[] args){
        WeakHashMap<String, String> map = new WeakHashMap<String, String>();
            //将WeakHashMap中添加三个key-value对,
            //三个key都是匿名字符串对象(没有其他引用)
            map.put(new String("语文"), new String("优"));
            map.put(new String("数学"), new String("良"));
            map.put(new String("英语"), new String("中"));
            //将WeakHashMap中添加一个key-value对,
            //该key是一个系统缓存的字符串对象。
            map.put("java", new String("不及格"));
            //输出map对象,将看到4个key-value对{java=不及格, 数学=良, 英语=中, 语文=优}
            System.out.println(map);
            //通知系统立即进行垃圾回收
            System.gc();
            System.runFinalization();
            //通常情况下,将只看到一个key-value对{java=不及格}
            System.out.println(map);
    }
}

  从上面运行结果可以看出,当系统进行垃圾回收时,删除了WeakHashMap对象的前三个key-value对。这是因为添加前三个key-value对时,这三个key都是匿名字符串对象,只有WeakHashMap保留了对它们的弱引用。WeakHashMap对象中的第四组key-value对的key是一个字符串的直接量,系统会缓冲这个字符串直接量(即系统保留了对该字符串对象的强引用),所以垃圾回收时不会回收它。

  •  IdentityHashMap实现类

  IdentityHashMap实现类的实现机制与HashMap基本相似,但它在处理两个key相等时,比较独特:在IdentityHashMap中,当且仅当两个key严格相等时(key1 = key2)时,IdentityHashMap才认为两个key相等对于普通HashMap而言,只要key1和key2通过equals比较返回true,且它们的hashCode值相等即可

   IdentityHashMap提供了与HashMap基本相似的方法,也允许使用null做为key和value。与HashMap类似的是,IdentityHashMap不保证任何key-value对之间的顺序,更不能保证它们的顺序随时间的推移保持不变。

public class Test {
    public static void main(String[] args){
        IdentityHashMap<String, String> map = new IdentityHashMap<String, String>();
            //下面两行代码会向map中添加两条key-value对
            map.put(new String("语文"), "99");
            map.put(new String("语文"), "100");
            //下面两行代码会向map中添加一条key-value对
            map.put("java", "89");
            map.put("java", "69");
            //打印结果为{java=69, 语文=100, 语文=99}
            System.out.println(map);
    }
}

 

  •  EnumMap实现类

  EnumMap是一个与枚举类一起使用的Map实现,EnumMap中所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显示或隐式指定它对应的枚举类。

  EnumMap不允许使用null作为key值,但容许使用null值做为value。如果试图使用null做为key将抛出NullPointerException异常。如果仅仅只是查询是否包含值为null的key,或者仅仅只是使用删除值为null的key,都不会抛出异常。

enum Season{
    SPRING,SUMMER,AUTUMN,WINTER
}
public class Test {
    public static void main(String[] args){
        EnumMap<Season, String> map = new EnumMap<Season, String>(Season.class);
        //打印结果为{}
        System.out.println(map);
        map.put(Season.SPRING, "春");
        map.put(Season.SUMMER, "夏");
        map.put(Season.AUTUMN, "秋");
        map.put(Season.WINTER, "冬");
        //打印结果为{SPRING=春, SUMMER=夏, AUTUMN=秋, WINTER=冬}
        System.out.println(map);
    }
}

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


 

  对于Map的常用实现类而言,HashMap和Hashtable的效率大致相同,因为它们的实现机制几乎完全一样,但HashMap通常比Hashtable要快一点,因为Hashtable额外实现同步操作。

  TreeMap通常比HashMap、Hashtable要慢(尤其在插入、删除key-value对的时候更慢),因为TreeMap需要额外的红黑树操作来维护key之间的次序。但使用TreeMap有一个好处:TreeMap中的key-value对总是处于有序状态,无须专门进行排序操作。

Java集合框架(五)—— Map、HashMap、Hashtable、Properties、SortedMap、TreeMap、WeakHashMap、IdentityHashMap、EnumMap

标签:封装   sort   tac   als   引用类型   集合框架   查找   system   相同   

原文地址:https://www.cnblogs.com/guoyaohua/p/8438142.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!