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

  • 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的代码演示。

修饰符和类型

方法和描述

Map.Entry<K,V>

ceilingEntry(K key) 返回大于或等于给定键相关联的与最小键 - 值映射,或者null如果不存在这样的键。

K

ceilingKey(K key) 返回大于或等于给定键的最小键,或者null如果不存在这样的键。

void

clear() 从此映射中删除所有映射。

Object

clone() 返回此TreeMap实例的浅表副本。

Comparator<? super K>

comparator() 返回用于对此映射中的键进行排序的比较器,或者 null此映射使用其键的自然排序。

boolean

containsKey(Object key) true如果此映射包含指定键的映射,则返回。

boolean

containsValue(Object value) 返回true如果此映射将一个或多个键映射到指定值。

NavigableSet<K>

descendingKeySet() 返回NavigableSet此映射中包含的键的逆序视图。

NavigableMap<K,V>

descendingMap() 返回此映射中包含的映射的逆序视图。

Set<Map.Entry<K,V>>

entrySet() 返回Set此映射中包含的映射的视图。

Map.Entry<K,V>

firstEntry() 返回与此地图中最小键相关的键值映射,或者null地图为空。

K

firstKey() 返回此地图中当前第一个(最低)的键。

Map.Entry<K,V>

floorEntry(K key) 返回与最大键小于或等于给定键相关联的键 - 值映射,如果不存在这样的键,则返回null。

K

floorKey(K key) 返回小于或等于给定键的最大键,如果不存在这样的键返回null。

void

forEach(BiConsumer<? super K,? super V> action) 对此映射中的每个条目执行给定操作,直到处理完所有条目或操作抛出异常为止。

V

get(Object key) 返回指定键映射到的值,或者null此映射不包含键的映射。

SortedMap<K,V>

headMap(K toKey) 返回此映射的关键字严格小于的部分的视图toKey。

NavigableMap<K,V>

headMap(K toKey, boolean inclusive) 返回此映射关键字小于(或等于,如果inclusive为真)的部分的视图toKey。

Map.Entry<K,V>

higherEntry(K key) 返回与最小键相关的键 - 值映射严格大于给定键,或者null如果不存在这样的键。

K

higherKey(K key) 返回严格大于给定键的最小键,或者 null如果不存在这样的键。

Set<K>

keySet() 返回Set此映射中包含的键的视图。

Map.Entry<K,V>

lastEntry() 返回与此地图中最大键关联的键值映射,或者null映射为空。

K

lastKey() 返回此地图中当前最后一个(最高)的键。

Map.Entry<K,V>

lowerEntry(K key) 返回与最大键相关的键 - 值映射严格小于给定键,或者null如果没有这样的键。

K

lowerKey(K key) 返回最大的密钥严格小于给定的密钥,或者 null如果没有这样的密钥。

NavigableSet<K>

navigableKeySet() 返回NavigableSet此映射中包含的键的视图。

Map.Entry<K,V>

pollFirstEntry() 移除并返回与此地图中的最小键相关联的键值映射,或者null地图为空。

Map.Entry<K,V>

pollLastEntry() 移除并返回与此地图中最大键关联的键值映射,或者null地图为空。

V

put(K key, V value) 将指定的值与此映射中指定的键关联。

void

putAll(Map<? extends K,? extends V> map) 将指定地图中的所有映射复制到此地图。

V

remove(Object key) 如果存在,则从此TreeMap中移除此键的映射。

V

replace(K key, V value) 仅当指定键的条目映射到某个值时才替换该条目。

boolean

replace(K key, V oldValue, V newValue) 仅当当前映射到指定值时才替换指定键的条目。

void

replaceAll(BiFunction<? super K,? super V,? extends V> function) 用对该条目调用给定函数的结果替换每个条目的值,直到处理完所有条目或者该函数抛出异常。

int

size() 返回此映射中键值映射的数量。

NavigableMap<K,V>

subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回此键映射范围从0 fromKey到的部分视图 toKey。

SortedMap<K,V>

subMap(K fromKey, K toKey) 返回此映射部分的视图,其键范围从 fromKey(包含)到toKey独占。

SortedMap<K,V>

tailMap(K fromKey) 返回此映射的键大于或等于的部分的视图fromKey。

NavigableMap<K,V>

tailMap(K fromKey, boolean inclusive) 返回此映射关键字大于(或等于,如果inclusive为真)的部分的视图fromKey。

Collection<V>

values() 返回Collection此映射中包含的值的视图。

  • 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对总是处于有序状态,无须专门进行排序操作。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏恰同学骚年

剑指Offer面试题:12.在O(1)时间删除链表结点

  在单向链表中删除一个结点,最常规的做法无疑是从链表的头结点开始,顺序遍历查找要删除的结点,并在链表中删除该结点。这种思路由于需要顺序查找,时间复杂度自然就是...

691
来自专栏Java帮帮-微信公众号-技术文章全总结

Java集合详解【面试+工作】

在说集合前我们不得不说一下数组 数组的作用: 存放一组相同的数据类型(基本或对象)的数据,从而实现对数据的管理 优势:可以快速的通过下标对数组元素进行访问,效率...

4356
来自专栏Java 源码分析

HashSet 源码分析

HashSet 源码分析 1. 在阅读源码时做了大量的注释,并且做了一些测试分析源码内的执行流程,由于博客篇幅有限,并且代码阅读起来没有 IDE 方便,所以在...

3164
来自专栏个人分享

LinkedHashMap的实现原理(复习)

   LinkedHashMap是Map接口的哈希表和链接列表实现,具有可预知的迭代顺序。此实现提供所有可选的映射操作,并允许使用null值和null键。此类不...

1044
来自专栏云霄雨霁

字符串查找----R向单词查找树

1060
来自专栏Java后端技术栈

初探Java源码之LinkedList

上篇文章我们分析了常见的ArrayList源码,它的内部是由一个数组来实现的。那么今天,我们来分析另一个常见的类LinkedList。本文分析都来自Java8。...

1192
来自专栏wannshan(javaer,RPC)

JDK PriorityBlockingQueue remove(Object o) 源码分析

先知道PriorityBlockingQueue 是利用数组存储二叉堆实现。最小值(最优先)放在queue[0]位置。 //删除某个元素 public bool...

3587
来自专栏来自地球男人的部落格

Comparison method violates its general contract!

今天在刷LeetCode题目的时候,问题使用HashMap按照value排序来解决,自定义比较器,但是报错:java.lang.IllegalArgumentE...

2428
来自专栏小二的折腾日记

LeetCode-49-Group-Anagrams

输入一个字符串数组,输出的是:将相同字符的字符串放在一个数组的二维数组。相同字符的处理,基本就是要对字符串排序的。然后需要考虑的就是排序好的那一个字符串怎么存的...

701
来自专栏用户画像

HashSet和HashMap的区别 && HashTable和HashMap的区别

2.Hashtable 中的方法是同步的,而HashMap中的方法在缺省情况下是非同步的。

913

扫码关注云+社区