Java集合系列（11）--Map总结

首先我们来看看Map的框架图

一、Map基本概述

Map是（Key-Value）键值对映射的抽象接口；AbstractMap实现了Map中的大部分方法接口，减少了Map的实现类的重复编码；SortMap为有序的键值对的映射接口；NavigableMap是继承于SortedMap的，支持搜索元素的接口。
HashMap、Hashtable、TreeMap、WeakHashMap为Map的实现类。
HashMap是基于拉链法实现的散列表（链表+数组），一般用于单线程中；
Hashtable基于拉链法实现的散列表（链表+数组），一般用于多线程；
WeakHashMap基于拉链法实现的散列表（（链表+数组）），一般用于单线程中。
TreeMap是有序的散列表（链表+数组），是通过红黑树实现的。一般用于单线程中。

二、HashMap与Hashtable的异同

HashMap与Hashtable的相同点
HashMap和Hashtable底层都是散列表（链表+数组），并且都是采用拉链法来实现的。
存储的思想：通过table数组存储，数组的每一个元素都是一个Entry，而每一个Entry都是一个单向链表，Entry链表中的每一个节点就保存了key-value键值对数据。
添加元素时，首先根据key值计算出哈希值，再计算出数组索引，然后根据数组索引找到Entry（单向链表），再遍历单向链表，将key和链表中的每一个节点的key进行对比。若key已经存在Entry链表中，则用该value值取代之前的value值；若key不在Entry链表中，则新建一个key-value节点，并将该节点插入Entry链表的表头位置。
删除元素时，首先根据key值计算出哈希值，再计算出数组索引，然后根据索引展出Entry（单向链表），若节点key-value存在于链表Entry中，则删除链表中的节点。
HashMap与Hashtable的相同点
1、继承和实现方式不同
HashMap继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
Hashtable继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口
区别在于HashMap继承了AbstractMap,而Hashtable继承了Dictionary。下面简单讲解：
Dictionary是一个抽象类，它直接继承于Object类，没有实现任何接口。Dictionary类是JDK1.0时引入的，尽管支持add（）、get（）、size（）等方法，但其API没有Map多。Dictionary一般是通过Enumeration（枚举类）去遍历，Map则是通过Iterator（迭代器）去遍历。然而，由于Hashtable也实现了Map接口。因此枚举类遍历和迭代遍历都可以。
AbstractMap为一个抽象类，它实现了Map接口的绝大部分API方法。
2、线程安全不同
Hashtable是同步的，即是线程安全的，一般用于多线程环境下。
HashMap是非同步的，即不是线程安全的，若要在多线程中使用HashMap，需要进行的额外的同步处理，比如使用synchronizedMap静态方法，或者使用java.util.concurrent包里的ConcurrentHashMap。
3、对null值的处理不同
HashMap的key、value都可以为。
Hashtable的key、value都不可以为null。
注意两者添加元素的方法：
HashMap添加元素

// 将“key-value”添加到HashMap中
public V put(K key, V value) {
    // 若“key为null”，则将该键值对添加到table[0]中。
    if (key == null)
        return putForNullKey(value);
    // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    // 若“该key”对应的键值对不存在，则将“key-value”添加到table中
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置
private V putForNullKey(V value) {
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            // recordAccess()函数什么也没有做
            e.recordAccess(this);
            return oldValue;
        }
    }
    // 添加第1个“key为null”的元素都table中的时候，会执行到这里。
    // 它的作用是将“设置table[0]的key为null，值为value”。
    modCount++;
    addEntry(0, null, value, 0);
    return null;
}

Hashtable添加元素

// 将“key-value”添加到Hashtable中
public synchronized V put(K key, V value) {
    // Hashtable中不能插入value为null的元素！！！
    if (value == null) {
        throw new NullPointerException();
    }

    // 若“Hashtable中已存在键为key的键值对”，
    // 则用“新的value”替换“旧的value”
    Entry tab[] = table;
    // Hashtable中不能插入key为null的元素！！！
    // 否则，下面的语句会抛出异常！
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            V old = e.value;
            e.value = value;
            return old;
        }
    }

    // 若“Hashtable中不存在键为key的键值对”，
    // (01) 将“修改统计数”+1
    modCount++;
    // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
    //  则调整Hashtable的大小
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();

        tab = table;
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中 Entry<K,V> e = tab[index];
    // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。        
    tab[index] = new Entry<K,V>(hash, key, value, e);
    // (05) 将“Hashtable的实际容量”+1
    count++;
    return null;
}

由上述代码可以得到：
Hashtable的key和value值都不允许为空，否则会抛出空异常；
HashMap的key和value值可以为空，当HashMap的key为null时，HashMap会将其固定的插入到table[0]的位置，当有多个key为null时，table[0]会保留最后插入的value，对前面的值进行覆盖。
4、支持的遍历种类不同
HashMap只支持迭代器（Iterator）遍历；
HashtablezhichEnumeration（枚举类）和Iterator（迭代器）两种方式遍历。
5、通过Iterator迭代器遍历时，遍历的顺序不同
HashMap是从前向后的遍历数组，再对数组具体某一项对应的链表，从表头开始遍历。
Hashtable是从前向后遍历数组，再对数组具体，某一项对应的链表，从表头开始进行遍历。
HashMap的实现方式

// 返回“HashMap的Entry集合”
public Set<Map.Entry<K,V>> entrySet() {
    return entrySet0();
}
// 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
private Set<Map.Entry<K,V>> entrySet0() {
    Set<Map.Entry<K,V>> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet对应的集合
// EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    ...
    public Iterator<Map.Entry<K,V>> iterator() {
        return newEntryIterator();
    }
    ...
}
// 返回一个“entry迭代器”
Iterator<Map.Entry<K,V>> newEntryIterator()   {
    return new EntryIterator();
}
// Entry的迭代器
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
    public Map.Entry<K,V> next() {
        return nextEntry();
    }
}
private abstract class HashIterator<E> implements Iterator<E> {
    // 下一个元素
    Entry<K,V> next;
    // expectedModCount用于实现fail-fast机制。
    int expectedModCount;
    // 当前索引
    int index;
    // 当前元素
    Entry<K,V> current;

    HashIterator() {
        expectedModCount = modCount;
        if (size > 0) { // advance to first entry
            Entry[] t = table;
            // 将next指向table中第一个不为null的元素。
            // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。
            while (index < t.length && (next = t[index++]) == null)
                ;
        }
    }

    public final boolean hasNext() {
        return next != null;
    }

    // 获取下一个元素
    final Entry<K,V> nextEntry() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        Entry<K,V> e = next;
        if (e == null)
            throw new NoSuchElementException();

        // 注意！！！
        // 一个Entry就是一个单向链表
        // 若该Entry的下一个节点不为空，就将next指向下一个节点;
        // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。
        if ((next = e.next) == null) {
            Entry[] t = table;
            while (index < t.length && (next = t[index++]) == null)
                ;
        }
        current = e;
        return e;
    }

    ...
}

Hashtable的实现方式

public Set<Map.Entry<K,V>> entrySet() {
    if (entrySet==null)
        entrySet = Collections.synchronizedSet(new EntrySet(), this);
    return entrySet;
}

private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public Iterator<Map.Entry<K,V>> iterator() {
        return getIterator(ENTRIES);
    }
    ...
}

private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
    // 指向Hashtable的table
    Entry[] table = Hashtable.this.table;
    // Hashtable的总的大小
    int index = table.length;
    Entry<K,V> entry = null;
    Entry<K,V> lastReturned = null;
    int type;

    // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志
    // iterator为true，表示它是迭代器；否则，是枚举类。
    boolean iterator;

    // 在将Enumerator当作迭代器使用时会用到，用来实现fail-fast机制。
    protected int expectedModCount = modCount;

    Enumerator(int type, boolean iterator) {
        this.type = type;
        this.iterator = iterator;
    }

    // 从遍历table的数组的末尾向前查找，直到找到不为null的Entry。
    public boolean hasMoreElements() {
        Entry<K,V> e = entry;
        int i = index;
        Entry[] t = table;
        /* Use locals for faster loop iteration */
        while (e == null && i > 0) {
            e = t[--i];
        }
        entry = e;
        index = i;
        return e != null;
    }

    // 获取下一个元素
    // 注意：从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式”
    // 首先，从后向前的遍历table数组。table数组的每个节点都是一个单向链表(Entry)。
    // 然后，依次向后遍历单向链表Entry。
    public T nextElement() {
        Entry<K,V> et = entry;
        int i = index;
        Entry[] t = table;
        /* Use locals for faster loop iteration */
        while (et == null && i > 0) {
            et = t[--i];
        }
        entry = et;
        index = i;
        if (et != null) {
            Entry<K,V> e = lastReturned = entry;
            entry = e.next;
            return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
        }
        throw new NoSuchElementException("Hashtable Enumerator");
    }

    // 迭代器Iterator的判断是否存在下一个元素
    // 实际上，它是调用的hasMoreElements()
    public boolean hasNext() {
        return hasMoreElements();
    }

    // 迭代器获取下一个元素
    // 实际上，它是调用的nextElement()
    public T next() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        return nextElement();
    }

    ...

}

6、容量的初始值和增加方式不同
HashMap默认的容量大小是16，增加容量时，原始容量的两倍；
Hashtable默认的容量大小是11；增加容量时，原始容量的2倍加1。
HashMap和Hashtable默认的加载因子0.75.
7、添加Key-Value时的hash值算法不同
HashMap添加元素时，是使用自定义的哈希算法。
Hashtable没有自定义哈希算法，而直接采用key的hashCode（）。
HashMap添加元素时，是使用自定义的哈希算法。

static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

// 将“key-value”添加到HashMap中
public V put(K key, V value) {
    // 若“key为null”，则将该键值对添加到table[0]中。
    if (key == null)
        return putForNullKey(value);
    // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    // 若“该key”对应的键值对不存在，则将“key-value”添加到table中
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

Hashtable没有自定义哈希算法，而直接采用的key的hashCode()。

public synchronized V put(K key, V value) {
    // Hashtable中不能插入value为null的元素！！！
    if (value == null) {
        throw new NullPointerException();
    }

    // 若“Hashtable中已存在键为key的键值对”，
    // 则用“新的value”替换“旧的value”
    Entry tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            V old = e.value;
            e.value = value;
            return old;
            }
    }

    // 若“Hashtable中不存在键为key的键值对”，
    // (01) 将“修改统计数”+1
    modCount++;
    // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
    //  则调整Hashtable的大小
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();

        tab = table;
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中
    Entry<K,V> e = tab[index];
    // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。        
    tab[index] = new Entry<K,V>(hash, key, value, e);
    // (05) 将“Hashtable的实际容量”+1
    count++;
    return null;
}

8、两者部分API不同
HashMap不支持contains(Object value)方法，没有重写toString()方法；
而Hashtable支持contains(Object value)方法，而且重写了toString()方法。
补充：两者使用场景总结
根据上述总结的特点，一般单线程环境下，使用HashMap；而多线程环境爱下，使用HashTable,当然，多线程环境下，也可以使用ConcurrentHashMap。

三、HashMap和WeakHashMap异同点

HashMap和WeakHashMap的相同点
HashMap和WeakHashMap底层都是散列表(链表+数组)，存储的是key-value键值对；都继承于AbstractMap，实现Map接口；都包括四个构造函数，且参数一样；默认的初始容量都是16，默认的加载因子都是0.75；两者key和value都允许为null。
两者都是非同步的，即不是线程安全的。
HashMap和WeakHashMap的不同点
1、HashMap实现了Cloneable和Serializable接口， 而WeakHashMap没有。
HashMap实现Cloneable，意味着它能通过clone()克隆自己。
HashMap实现Serializable，意味着它支持序列化，能通过序列化去传输。
2、HashMap的键是强引用，而WeakHashMap的键是弱引用。
WeakReference的“弱键”能实现WeakReference对“键值对”的动态回收。当“弱键”不再被使用到时，GC会回收它，WeakReference也会将“弱键”对应的键值对删除。

文章只是作为自己的学习笔记，借鉴了网上的许多案例，如果觉得阔以的话，希望多交流，在此谢过…