Java底层类和源码分析系列-HashMap底层架构和源码分析

几个要点

• HashMap底层的数据结构基于链表(O(n))和红黑树(O(logN))的数组；
• HashMap允许空key和空value；
• HashMap元素非按照写入时顺序排序，而是按Key的hash取n模来排序（算法优化采用(n - 1) & hash）
• HashMap非线程安全类，Hashtable也是线程安全的，但它是直接在方法上使用synchronized，是利用阻塞式的锁保证线程安全的，其并发效率低。可考虑Concurrent包，如ConcurrentHashMap；
• HashMap 并不保证键值对的顺序，这意味着在进行某些操作后（如rehash），键值对的顺序可能会发生变化；
• 默认初始化容量为16(扩容必须是2的n次方)；
• 最大容量为2的30次方，2^(30) = 1,073,741,824；
• 链表长度大于8时转为树；
• HashMap默认的“负载极限”为0.75，表明该hash表3/4已经被填满时，hash表会发生rehashing。0.75其实是事件和空间的一个折中：较高的“负载极限”可以降低hash表所占的内存空间，但会增加查询数据的开销，而查询是最频繁的操作；而较低的“负载极限”会增加查询的性能，但会增加hash表所占的内存空间。
• 哈希算法的优化是对每个hash值，在其低16位中，让高低16位进行了异或，同时让其低16位同时保持了高低16位的特征，尽量避免一些hash值后续出现冲突，具体可见https://www.zhihu.com/question/20733617
• HashMap解决哈希冲突的方法是采用”链地址法“，也就是数组+链表（红黑树）的方式；
• 寻址算法优化采用(n - 1) & hash（与运算）来替代数组取模定位；
• 不论是添加键值对、删除键值对或获取键对应的值，其基本流程都是先确定算出Key的hash,再根据hash找到对应的table索引（即找到哈希桶），再确定节点应在哈希桶的哪个位置。
• 键的hash是随机的，这导致表达式“(n - 1) & hash”的结果是无规律可循的，因此HashMap的键值对是无序的。若要使用有序的HashMap，请使用其子类LinkedHashMap.
• 哈希表table每次扩容后，键值对Entry所在的哈希桶的索引，可能不变，即就是原来的index ,也有可能变成（index+oldCap），且只有这两种可能的情况。

变量

/**
* 默认初始容量16(必须是2的幂次方)
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

/**
* 最大容量，2的30次方, 2^(30) = 1,073,741,824
*/
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
* 默认加载因子，用来计算threshold
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
* 链表转成树的阈值，当桶中链表长度大于8时转成树 
threshold = capacity * loadFactor
*/
static final int TREEIFY_THRESHOLD = 8;

/**
* 进行resize操作时，若桶中数量少于6则从树转成链表
*/
static final int UNTREEIFY_THRESHOLD = 6;

/**
* 桶中结构转化为红黑树对应的table的最小大小

当需要将解决 hash 冲突的链表转变为红黑树时，需要判断下此时数组容量，若是由于数组容量太小（小于　MIN_TREEIFY_CAPACITY　）导致的 hash 冲突太多，则不进行链表转变为红黑树操作，
转为利用　resize() 函数对　hashMap 扩容
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
保存Node<K,V>节点的数组,该表在首次使用时初始化，并根据需要调整大小。 分配时，长度始终是2的幂。
*/
transient Node<K,V>[] table;

/**
* 存放具体元素的集
*/
transient Set<Map.Entry<K,V>> entrySet;

/**
* 记录 hashMap 当前存储的元素的数量
*/
transient int size;

/**
* 每次更改map结构的计数器
*/
transient int modCount;

/**
* 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
*/
int threshold;

/**
* 负载因子：要调整大小的下一个大小值（容量*加载因子）。
*/
final float loadFactor;

构造方法

/**
 * 传入初始容量大小，使用默认负载因子值 来初始化HashMap对象
 */
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * 默认容量和负载因子
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
 * 传入初始容量大小和负载因子 来初始化HashMap对象
 */
public HashMap(int initialCapacity, float loadFactor) {
    // 初始容量不能小于0，否则报错
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    // 初始容量不能大于最大值，否则为最大值                                       
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //负载因子不能小于或等于0，不能为非数字    
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    // 初始化负载因子                                       
    this.loadFactor = loadFactor;
    // 初始化threshold大小
    this.threshold = tableSizeFor(initialCapacity);
}

获取2倍capacity容量的最小值

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

利用位右移，这里cap = 536,870,913 = 2 power 29 + 1，多次计算后，算出n + 1 = 1,073,741,824 = 2 power 30

静态内部类Node

Node表示包含一个键-值对基础的哈希节点。

static class Node<K,V> implements Map.Entry<K,V>

一个Node实例表示单向链表的一个节点，当这个实例是头节点时，这个实例又可以直接表示整个链表。

Node类中有4个成员变量:

• final int hash;
• final K key;
• V value;
• Node<K,V> next;

key value分别表示当前节点的键和值
next表示下个节点的引用（默认情况下使用链表处理哈希冲突，所以必须要有后继节点的引用）
hash表示将key进行哈希运算后的结果(使用HashMap的静态方法"hash（Object）"计算)，此属性非常重要，它决定当前节点放在哈希表的哪个桶上。

静态内部类TreeNode

TreeNode也表示包含一个键-值对基础的哈希节点，一个红黑树节点，由于它间接继承上面提到的Node,因此它也可以表示为一个单向链表节点。

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {

当一个桶上的节点少于8个时，使用Node当作哈希节点，当一个桶上的节点多于8个时，即哈希冲突严重时，使用TreeNode。

TreeNode中有5个成员变量。

parent、left 、right 、prev分别表示父节点、左节点、右节点、前节点

red表示当前节点的红/黑点

TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;

查找

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
// 获取hash值
static final int hash(Object key) {
    int h;
    // 拿到key的hash值后与其五符号右移16位取与
    // 通过这种方式，让高16位数据与低16位数据进行异或，以此加大低位信息的随机性，变相的让高位数据参与到计算中。
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; 
    Node<K,V> first, e; 
    int n; K k;
    // 定位键值对所在桶的位置
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 判断桶中第一项(数组元素)相等
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶中不止一个结点
        if ((e = first.next) != null) {
            // 是否是红黑树，是的话调用getTreeNode方法
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 不是红黑树的话，在链表中遍历查找    
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

这里通过(n - 1)& hash即可算出桶的在桶数组中的位置，因为HashMap 中桶数组的大小 length 总是2的幂，此时，(n - 1) & hash 等价于对 length 取余。但取余的计算效率没有位运算高，所以(n - 1) & hash也是一个小的优化。

计算键的 hash 值

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

hash 是 int 类型，32 位宽。前16位为高位，后16位为低位，所以要右移16位。

上面所说的是重新计算 hash 的一个好处，除此之外，重新计算 hash 的另一个好处是可以增加 hash 的复杂度。当我们覆写 hashCode 方法时，可能会写出分布性不佳的 hashCode 方法，进而导致 hash 的冲突率比较高。通过移位和异或运算，可以让 hash 变得更复杂，进而影响 hash 的分布性。

添加

public V put(K key, V value) {
    // 调用hash(key)方法来计算hash 
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; 
    Node<K,V> p; 
    int n, i;
    // 容量初始化：当table为空，则调用resize()方法来初始化容器
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //确定元素存放在哪个桶中，桶为空，新生成结点放入桶中
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            //如果键的值以及节点 hash 等于链表中的第一个键值对节点时，则将 e 指向该键值对
            e = p;
        // 如果桶中的引用类型为 TreeNode，则调用红黑树的插入方法
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //对链表进行遍历，并统计链表长度
            for (int binCount = 0; ; ++binCount) {
                // 到达链表的尾部
                if ((e = p.next) == null) {
                    //在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    // 如果结点数量达到阈值，转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //判断要插入的键值对是否存在 HashMap 中
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            // onlyIfAbsent 表示是否仅在 oldValue 为 null 的情况下更新键值对的值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 键值对数量超过阈值时，则进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

首先定位要插入的键值对属于哪个桶，定位到桶后，再判断桶是否为空。如果为空，则将键值对存入即可。如果不为空，则需将键值对接在链表最后一个位置，或者更新键值对.

插入操作的入口方法是 put(K,V)，但核心逻辑在V putVal(int, K, V, boolean, boolean) 方法中。putVal 方法主要做了这么几件事情：

1. 当桶数组 table 为空时，通过扩容的方式初始化 table
2. 查找要插入的键值对是否已经存在，存在的话根据条件判断是否用新值替换旧值
3. 如果不存在，则将键值对链入链表中，并根据链表长度决定是否将链表转为红黑树
4. 判断键值对数量是否大于阈值，大于的话则进行扩容操作

扩容机制

在 HashMap 中，桶数组的长度均是2的幂，阈值大小为桶数组长度与负载因子的乘积。当 HashMap 中的键值对数量超过阈值时，进行扩容。

HashMap 按当前桶数组长度的2倍进行扩容，阈值也变为原来的2倍（如果计算过程中，阈值溢出归零，则按阈值公式重新计算）。扩容之后，要重新计算键值对的位置，并把它们移动到合适的位置上去。

final Node<K,V>[] resize() {
    // 拿到数组桶
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 如果数组桶的容量大与0
    if (oldCap > 0) {
        // 如果比最大值还大，则赋值为最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 如果扩容后小于最大值 而且 旧数组桶大于初始容量16， 阈值左移1(扩大2倍)
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    // 如果数组桶容量<=0 且 旧阈值 >0
    else if (oldThr > 0) // initial capacity was placed in threshold
        // 新容量=旧阈值
        newCap = oldThr;
    // 如果数组桶容量<=0 且 旧阈值 <=0
    else {               // zero initial threshold signifies using defaults
        // 新容量=默认容量
        newCap = DEFAULT_INITIAL_CAPACITY;
        // 新阈值= 负载因子*默认容量
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 如果新阈值为0
    if (newThr == 0) {
        // 重新计算阈值
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 更新阈值
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        // 创建新数组
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    // 覆盖数组桶    
    table = newTab;
    // 如果旧数组桶不是空，则遍历桶数组，并将键值对映射到新的桶数组中
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // 如果是红黑树
                else if (e instanceof TreeNode)
                    // 重新映射时，需要对红黑树进行拆分
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    // 如果不是红黑树，则按链表处理
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 遍历链表，并将链表节点按原顺序进行分组
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 将分组后的链表映射到新桶中
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

整体步骤：

• 计算新桶数组的容量 newCap 和新阈值 newThr
• 根据计算出的 newCap 创建新的桶数组，桶数组 table 也是在这里进行初始化的
• 将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通节点，则节点按原顺序进行分组。

总结起来，一共有三种扩容方式：

1. 使用默认构造方法初始化HashMap。从前文可以知道HashMap在一开始初始化的时候会返回一个空的table，并且thershold为0。因此第一次扩容的容量为默认值DEFAULT_INITIAL_CAPACITY也就是16。同时threshold = DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12。
2. 指定初始容量的构造方法初始化HashMap。那么从下面源码可以看到初始容量会等于threshold，接着threshold = 当前的容量（threshold） * DEFAULT_LOAD_FACTOR。
3. HashMap不是第一次扩容。如果HashMap已经扩容过的话，那么每次table的容量以及threshold量为原有的两倍。

遍历

有5种遍历hashmap的方法：

public static void main(String[] args) throws InterruptedException {
        Map<String, String> map = new HashMap<String, String>();
        map.put("7", "7");
        map.put("11", "11");
        map.put("43", "43");
        map.put("59", "59");
        map.put("19", "19");
        map.put("3", "3");
        map.put("35", "35");

        //方法1:entrySet,实际也是转化为迭代器
        System.out.println("adopt Map.entrySet ergodic key and value: ");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + " - Value: " + entry.getValue());
            System.out.println("Index: " + Math.floorMod(entry.getKey().hashCode(), 16)  );        
        }

        //方法2：直接使用迭代器
        System.out.println("
 adopt Map.entrySet Use iterator ergodic key and value: ");
        Iterator map1it = map.entrySet().iterator();
        while (map1it.hasNext()) {
            Map.Entry<String, String> entry = (Map.Entry<String, String>) map1it.next();
            System.out.println("Key: " + entry.getKey() + " - Value: " + entry.getValue());
        }

        //方法3:keySet
        System.out.println("
 adopt Map.keySet ergodic key and value: ");
        for (String key : map.keySet()) {
            System.out.println("Key: " + key + " - Value: " + map.get(key));
        }

        //方法4，只取values
        System.out.println("
 adopt Map.values()Traverse all value,But not traversal key: ");
        for (String v : map.values()) {
            System.out.println("The value is " + v);
        }
        //方法5，函数式forEach
        BiConsumer<String, String> biConsumer = (k, v) -> System.out.println(k + " : " + v );
        map.replaceAll((k,v)->v+"abc");
        map.computeIfAbsent("7", k -> "我已存在");
        map.computeIfAbsent("8", k -> "我不存在");
        map.forEach(biConsumer);
    }

为什么遍历读取的顺序和放入的顺序不同呢？HashMap元素非按照写入时顺序排序，而是按Key的hash取n模来排序（算法优化采用(n - 1) & hash）
转为二进制演算一下结果即可：

Key: 11 - Value: 11
Index: 0
Key: 35 - Value: 35
Index: 2
Key: 3 - Value: 3
Index: 3
Key: 59 - Value: 59
Index: 4
Key: 7 - Value: 7
Index: 7
Key: 19 - Value: 19
Index: 8
Key: 43 - Value: 43
Index: 15

函数式操作

仅举两个简单的forEach和replaceAll，核心就是for一遍之后执行接口accept方法

@Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e.key, e.value);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

    @Override
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Node<K,V>[] tab;
        if (function == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    e.value = function.apply(e.key, e.value);
                }
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

删除元素

@Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e.key, e.value);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

    @Override
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Node<K,V>[] tab;
        if (function == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    e.value = function.apply(e.key, e.value);
                }
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }