Map

基本概念

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

Map接口中定义了如下常用的方法

删除该Map对象中的所有key-value对

void clear();

查询Map中是否包含指定的key，如果包含则返回true

boolean containsKey(Object key);

查询Map中是否包含一个或多个value，如果包含则返回true

boolean containsValue(Object value);

返回Map中包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry（Entry是Map的内部类）对象

Set<Map.Entry<K, V>> entrySet();

返回指定key所对应的value；如果此Map中不包含该key，则返回null

V get(Object key);

查询该Map是否为空（即不包含任何key-value对），如果为空则返回true

boolean isEmpty();

返回该Map中所有key组成的Set集合

Set<K> keySet();

添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对

V put(K key, V value);

将指定Map中的key-value对复制到本Map中

void putAll(Map<? extends K, ? extends V> m);

删除指定key所对应的key-value对，返回被删除key所关联的value，如果该key不存在，则返回null

V remove(Object key);

返回该Map里的key-value对的个数

int size();

返回该Map里所有value组成的Collection

Collection<V> values();

Map接口提供了大量的实现类，典型实现如HashMap和Hashtable等、HashMap的子类LinkedHashMap，还有SortedMap子接口及该接口的实现类TreeMap，以及WeakHashMap、IdentityHashMap等。

Map中包括一个内部接口Entry，该类封装了一个key-value对。Entry包含如下三个方法
返回该Entry里包含的key值

K getKey();

返回该Entry里包含的value值

V getValue();

设置该Entry里包含的value值，并返回新设置的value值

V setValue(V value);

HashMap和Hashtable实现类

HashMap和Hashtable都是Map接口的典型实现类，它们之间的关系完全类似于ArrayList和Vector的关系。

HashMap和Hashtable存在两点典型区别

• Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable性能高一点；但如果有多个线程访问同一个Map对象时，使用Hashtable实现类会更好
• Hashtable不允许使用null作为key和value，如果试图把null值放进Hashtable中，将会引发NullPointerException异常；但HashMap可以使用null作为key或value

public class NullInHashMap {

    public static void main(String[] args) {
        HashMap hm = new HashMap();
        hm.put(null, null);
        hm.put(null, "a");
        hm.put("a", null);

        System.out.println(hm);
    }

}

{null=a, a=null}

由以上代码可以看出HashMap的key可以为null，如果key重复则会覆盖掉HashMap中的key-value对

从Hashtable的类名上就可以看出它是一个古老的类，它的命名甚至没有遵守Java的命名规范：每个单词的首字母都应该大写。也许当初开发Hashtable的工程师也没有注意到这一点，后来大量Java程序中使用了Hashtable类，所以这个类名也就不能改为HashTable了，否则将导致大量程序需要改写。与Vector类似的是，尽量少用Hashtable实现类，即使需要创建线程安全的Map实现类，也无须使用Hashtable实现类，可以通过Collections工具类把HashMap变成线程安全的。

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

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

当使用自定义类作为HashMap、Hashtable的key时，如果重写该类的equals(Object obj)和hashCode()方法，则应该保证两个方法的判断标准一致，当两个key通过equals()方法比较返回true时，两个key的hashCode()返回值也应该相同。因为HashMap、Hashtable保存key的方式与HashSet保存集合元素的方式完全相同，所以HashMap、Hashtable对key的要求与HashSet对集合元素的要求完全相同。

与HashSet类似的是，如果使用可变对象作为HashMap、Hashtable的key，并且程序修改了作为key的可变对象，则也可能出现与HashSet类似的情形：程序再也无法准确访问到Map中被修改过的key。

public class HashtableErrorTest {

    public static void main(String[] args) {
        Hashtable ht = new Hashtable();
        ht.put(new A(60000), "疯狂Java讲义");
        ht.put(new A(87563), "轻量级Java EE企业应用实战");
        Iterator it = ht.keySet().iterator();
        A first = (A) it.next();
        first.count = 87563;

        System.out.println(ht);
        //只能删除没有被修改过的key所对应的key-value对
        ht.remove(new A(87563));
        System.out.println(ht);
        //无法获取剩下的value，下面两行代码都将输出null
        System.out.println(ht.get(new A(87563)));
        System.out.println(ht.get(new A(60000)));

    }

}

class A{
    int count;

    public A(int count){
        this.count = count;
    }

    @Override
    public boolean equals(Object obj){
        if (this == obj) return true;
        if (obj != null && obj.getClass() == A.class){
          A a = (A) obj;
          return a.count == this.count;
        }

        return false;

    }

    @Override
    public int hashCode(){
        return this.count;
    }

}

输出结果

{A@1560b=疯狂Java讲义, A@1560b=轻量级Java EE企业应用实战}
{A@1560b=疯狂Java讲义}
null
null

与HashSet类似的是，尽量不要使用可变对象作为HashMap、Hashtable的key，如果确实需要使用可变对象作为HashMap、Hashtable的key，则尽量不要在程序中修改作为key的可变对象

LinkedHashMap实现类

HashSet有一个子类是LinkedHashSet，HashMap也有一个LinkedHashMap子类；LinkedHashMap也是用双向链表来维护key-value对的次序（其实只需要考虑key的次序），该链表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。

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

public class LinkedHashMapTest {

    public static void main(String[] args) {
        LinkedHashMap scores = new LinkedHashMap();

        scores.put("语文", 80);
        scores.put("英文", 82);
        scores.put("数学", 76);

        for (Object key : scores.keySet()){
            System.out.println(key + "  " + scores.get(key));
        }

    }

}

语文  80
英文  82
数学  76

使用Properties读写属性文件

Properties类是Hashtable类的子类，正如它的名字所暗示的，该对象在处理属性文件时特别方便（Windows操作平台上的ini文件就是一种属性文件）。Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件中，也可以把属性文件中的属性名=属性值加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型，所以Properties里的key、value都是字符串类型。

该类提供了如下三个方法来修改Properties里的key、value值

获取Properties中指定属性名对应的属性值，类似于Map的get(Object key)方法

   public String getProperty(String key) {
        Object oval = super.get(key);
        String sval = (oval instanceof String) ? (String)oval : null;
        return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
    }

该方法与前一个方法基本相似。该方法多一个功能，如果Properties中不存在指定的key时，则该方法指定默认值。

    public String getProperty(String key, String defaultValue) {
        String val = getProperty(key);
        return (val == null) ? defaultValue : val;
    }

设置属性值，类似于Hashtable的put()方法

    public synchronized Object setProperty(String key, String value) {
        return put(key, value);
    }

除此之外，它还提供了两个读写属性文件的方法

从属性文件（以输入流表示）中加载key-value对，把加载到key-value对追加到Properties里（Properties是Hashtable的子类，它不保证key-value对之间的次序）

    public synchronized void load(InputStream inStream) throws IOException {
        load0(new LineReader(inStream));
    }

将Properties中的key-value对输出到指定的属性文件（以输出流表示）中

    public void store(OutputStream out, String comments)
        throws IOException
    {
        store0(new BufferedWriter(new OutputStreamWriter(out, "8859_1")),
               comments,
               true);
    }

public class PropertiesTest {

    public static void main(String[] args) throws Exception{
        Properties props = new Properties();
        //向Properties中添加属性
        props.setProperty("username", "yeeku");
        props.setProperty("password", "123456");
        //将Properties中的key-value对保存到a.ini文件中
        props.store(new FileOutputStream("a.ini"), "comment line");

        //新建一个Properties对象
        Properties props2 = new Properties();
        //向Properties中添加属性
        props2.setProperty("gender", "male");
        //将a.ini文件中的key-value对追加到props2中
        props2.load(new FileInputStream("a.ini"));
        System.out.println(props2);

    }

}

{password=123456, gender=male, username=yeeku}

Properties可以把key-value对以XML文件的形式保存起来，也可以从XML文件中加载key-value

SortedMap接口和TreeMap实现类

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

TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。TreeMap也有两种排序方式。

• 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出ClassCastException异常
• 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口

类似于TreeSet中判断两个元素相等的标准，TreeMap中判断两个key相等的标准是：两个key通过compareTo()方法返回0，TreeMap即认为这两个key是相等的。

如果使用自定义类作为TreeMap的key，且想让TreeMap良好地工作，则重写该类的equals()方法和compareTo()方法时应保持一致的返回结果：两个key通过equals()方法比较返回true时，它们通过compareTo()方法比较应该返回0。如果equals()方法与compareTo()方法的返回结果不一致，TreeMap与Map接口的规则就会冲突。

Set和Map的关系十分密切，Java源码就是先实现了HashMap、TreeMap等集合，然后通过包装一个所有的value都为private static final Object PRESENT = new Object();的Map集合实现了Set集合类

与TreeSet类似的是，TreeMap中也提供了一系列根据key顺序访问key-value对的方法。

返回该Map中最小key所对应的key-value对，如果该Map为空，则返回null

    public Map.Entry<K,V> firstEntry() {
        return exportEntry(getFirstEntry());
    }

返回该Map中最小key值，如果该Map为空，则返回null

    public K firstKey() {
        return key(getFirstEntry());
    }

返回该Map中最大key所对应的key-value对，如果该Map为空或不存在这样的key-value对，则都返回null

    public Map.Entry<K,V> lastEntry() {
        return exportEntry(getLastEntry());
    }

返回该Map中的最大key值，如果该Map为空或不存在这样的key，则都返回null

    public K lastKey() {
        return key(getLastEntry());
    }

返回该Map中位于key后一位的key-value对（即大于指定key的最小key所对应的key-value对）。如果该Map为空，则返回null

    public Map.Entry<K,V> higherEntry(K key) {
        return exportEntry(getHigherEntry(key));
    }

返回该Map中位于key前一位的key-value对（即小于指定key的最大key所对应的key-value对）。如果该Map为空或不存在这样的key-value对，则都返回null

    public Map.Entry<K,V> lowerEntry(K key) {
        return exportEntry(getLowerEntry(key));
    }

返回该Map中位于key前一位的key值（即小于指定key的最大key值）。如果该Map为空或不存在这样的key，则都返回null

   public K lowerKey(K key) {
        return keyOrNull(getLowerEntry(key));
    }

返回该Map的子Map，其key的范围是从fromKey（是否包括取决于第二个参数）到toKey（是否包括取决于第四个参数）

    public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                                    K toKey,   boolean toInclusive) {
        return new AscendingSubMap<>(this,
                                     false, fromKey, fromInclusive,
                                     false, toKey,   toInclusive);
    }

返回该Map的子Map，其key的范围是从fromKey（包括）到toKey（不包括）

    public SortedMap<K,V> subMap(K fromKey, K toKey) {
        return subMap(fromKey, true, toKey, false);
    }

返回该Map的子Map，其key的范围是大于fromKey（包括）的所有key

    public SortedMap<K,V> tailMap(K fromKey) {
        return tailMap(fromKey, true);
    }

返回该Map的子Map，其key的范围是大于fromKey（是否包括取决于第二个参数）的所有key

    public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
        return new AscendingSubMap<>(this,
                                     false, fromKey, inclusive,
                                     true,  null,    true);
    }

返回该Map的子Map，其key的范围是小于toKey（不包括）的所有key

    public SortedMap<K,V> headMap(K toKey) {
        return headMap(toKey, false);
    }

返回该Map的子Map，其key的范围是小于toKey（是否包括取决于第二个参数）的所有key

    public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
        return new AscendingSubMap<>(this,
                                     true,  null,  true,
                                     false, toKey, inclusive);
    }

表面上看起来这些方法很复杂，其实它们很简单。因为TreeMap中的key-value对是有序的，所以增加了访问第一个、前一个、后一个、最后一个key-valule对的方法，并提供了几个从TreeMap中截取子TreeMap的方法

public class TreeMapTest {

    public static void main(String[] args) {
        TreeMap tm = new TreeMap();
        //因为Integer是实现了Comparable接口的，所以可以作为TreeMap的key
        tm.put(3, "aaa");
        tm.put(-5, "bbb");
        tm.put(9, "ccc");
        System.out.println(tm);
        //返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());
        //返回该TreeMap的最后一个key值
        System.out.println(tm.lastKey());
        //返回该TreeMap的比2大的最小key值
        System.out.println(tm.higherKey(2));
        //返回该TreeMap的比2小的最大key-value对
        System.out.println(tm.lowerEntry(2));
        //返回该TreeMap的子TreeMap
        System.out.println(tm.subMap(-1, 4));

    }

}

{-5=bbb, 3=aaa, 9=ccc}
-5=bbb
9
3
-5=bbb
{3=aaa}

WeakHashMap实现类

WeakHashMap与HashMap的用法基本相似。与HashMap的区别在于，HashMap的key保留了对实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMpa的所有key所引用的对象就不会被垃圾回收，HashMap也不会自动删除这些key所对应的key-value对；但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，WeakHashMap也可能自动删除这些key所对应的key-value对。

WeakHashMap中的每个key对象只持有对实际对象的弱引用，因此，当垃圾回收了该key所对应的实际对象之后，WeakHashMap会自动删除该key对应的key-value对。

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

{英文=中等, java=中等, 数学=及格, 语文=良好}
{java=中等}

如果需要使用WeakHashMap的key来保留对象的弱引用，则不要让该key所引用的对象具有任何强引用，否则将失去使用WeakHashMap的意义

IdentityHashMap实现类

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

public class IdentityHashMapTest {

    public static void main(String[] args) {
        IdentityHashMap ihm = new IdentityHashMap();

        //下面两行代码将会向IdentityHashMap对象中添加两个key-value
        ihm.put(new String("语文"), 89);
        ihm.put(new String("语文"), 78);

        //下面两行代码只会向IdentityHashMap对象中添加一个key-value
        ihm.put("java", 93);
        ihm.put("java", 98);

        System.out.println(ihm);


    }

}

{java=98, 语文=78, 语文=89}

EnumMap实现类

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

EnumMap在内部以数组形式保存，所以这种实现形式非常紧凑、高效。

EnumMap根据key的自然顺序（即枚举值在枚举类中的定义顺序）来维护key-value对的顺序。

与创建普通的Map有所区别是，创建EnumMap时必须指定一个枚举类，从而将该EnumMap和指定枚举类关联起来。

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);


    }

}

enum Season{
    SPRING,SUMMER,FALL,WINTER
}

{SPRING=春暖花开, SUMMER=夏日炎炎}

各Map实现类的性能分析

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

TreeMap通常比HashMap、Hashtable要慢（尤其在插入、删除key-value对时更慢），因为TreeMap底层采用红黑树来管理key-value对（红黑树的每个节点就是一个key-value）。

使用TreeMap有一个好处：TreeMap中的key-value对总是处于有序状态，无须专门进行排序操作。当TreeMap被填充之后，就可以调用keySet()，取得由key组成的Set，然后使用toArray()方法生成key的数组，接下来使用Arrays的binarySearch()方法在已排序的数组中快速地查询对象。

对于一般的应用场景，程序应该多考虑使用HashMap，因为HashMap正是为快速查询设计的（HashMap底层其实也是采用数组来存储key-value对）。但如果程序需要一个总是排好序的Map时，则可以考虑使用TreeMap。

LInkedHashMap比HashMap慢一点，因为它需要维护链表来保持Map中key-value时的添加顺序。IdentityHashMap性能没有特别出色之处，因为它采用与HashMap基本相似的实现，只是它使用==而不是equals()方法来判断元素相等。EnumMap的性能最好，但它只能使用同一个枚举类的枚举值作为key

HashSet和HashMap的性能选项

对于HashSet及其子类而言，它们采用hash算法来决定集合中元素的存储位置，并通过hash算法来控制集合的大小；对于HashMap、Hashtable及其子类而言，它们采用hash算法来决定Map中key的存储，并通过hash算法来增加key集合的大小。

hash表里可以存储元素的位置被称为桶（bucket），在通常情况下，单个桶里存储一个元素，此时有最好的性能：hash算法可以根据hashCode值计算出桶的存储位置，接着从桶中取出元素。但hash表的状态为open：在发生hash冲突的情况下，单个桶会存储多个元素，这些元素以链表形式存储，必须按顺序搜索。

因为HashSet和HashMap、Hashtable都使用hash算法来决定其元素的存储，因此HashSet、HashMap的hash表包含如下属性。

容量（capacity）

hash表中桶的数量

初始化容量（initial capacity）

创建hash表时桶的数量。HashMap和HashSet都允许在构造器中指定初始化容量

尺寸（size）

当前hash表中记录的数量

负载因子（load factor）

负载因子等于size/capacity。负载因子为0，代表空的hash表，0.5表示半满的散列表，以此类推。轻负载的散列表具有冲突少、适宜插入与查询的特点（但是使用Iterator迭代元素时比较慢）

除此之外，hash表里还有一个负载极限，负载极限是一个0~1的数值，负载极限决定了hash表的最大填满程度。当hash表中的负载因子达到指定的负载极限时，hash表会自动成倍地增加容量（桶的数量），并将原有的对象重新分配，放入新的桶内，这称为rehashing。

HashSet和HashMap、Hashtable的构造器允许指定一个负载极限，HashSet和HashMap、Hashtable默认的负载极限为0.75，这表明当该hash表的3/4已经被填满时，hash表会发生rehashing。

负载极限的默认值（0.75）是时间和空间成本上的一种折中