HashMap原理

HashMap底层是通过哈希表实现的, jdk1.8为了提升HashMap的性能又引入了红黑树, 下面我们来了解HashMap的数据结构.

哈希表

哈希表是一种数组+链表的数据结构, 其中储存的元素节点的数据结构如下:

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

在向哈希表中添加数据时, 会先求出key的哈希值, 然后以哈希值作为数组下标, 将数据存入数组中. 如果数组中下标对应的位置已存在数据, 此时会将数据添加到链表的末尾. 在向哈希表中查询数据时, 会先根据下标从数组中查询, 如果不匹配, 再遍历链表.

从添加和查询数据的过程中我们可以看出, 链表是限制哈希表性能的关键点, 添加和查询都要遍历链表, 这个时间复杂度是O(n), 当链表很长时, 就会严重影响性能.

红黑树

红黑树是一种近似的平衡二叉树, 它有如下性质:

• 节点是红色或黑色.
• 根是黑色.
• 所有叶子都是黑色（叶子是NIL节点）。
• 每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
• 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

以上性质确保了红黑树的一个特性: 从根到叶子的最长路径不会超过最短路径的两倍.

在向红黑树中插入和删除节点时, 为了确保其性质, 会进行节点颜色的变更和树的旋转(不会超过三次), 红黑树插入, 删除, 查询操作的时间复杂度为O(logn).

哈希表+红黑树

链表操作的时间复杂度为O(n), 红黑树操作的时间复杂度为O(logn), 所以jdk1.8在链表长度超过TREEIFY_THRESHOLD = 8时, 将链表转化为红黑树.

我们来看下源码:

(1) put

public V put(K key, V value) {
    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;
    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;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        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;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

HashMap初始化的时候没有设置初始容量, 第一次添加数据的时候会进行第一次扩容, 容量为DEFAULT_INITIAL_CAPACITY = 1 << 4 (16), 下次添加数据时, 如果已用容量达到tab.length(数组长度) * DEFAULT_LOAD_FACTOR(0.75), 就会进行扩容, 容量翻倍. 在向HashMap中添加数据时, 会先尝试添加到数组中, 如果数组中已存在, 再添加到链表末尾, 如果链表长度超过TREEIFY_THRESHOLD = 8, 会将链表转化为红黑树.

(2) get

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

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

从HashMap中查询数据时, 会先对key进行哈希, 再以哈希值作为下标从数组中查询数据, 如果不匹配, 再从链表或红黑树中查询.

(3) 观察put()和get()源码, HashMap如何保证哈希值作为数组下标不会越界?

因为HashMap将哈希值作为数组下标时做了如下操作:

tab[(n-1)&hash] 

n为数组长度, 且是偶数, 当转化为二进制数时为1000(…), n-1转为二进制数时为0111(…), 因为最高位为0, 所以和hash值进行与操作时结果一定不会超过n-1.