HashMap源码

HashMap源码分析

transient Node<K,V>[] table;

数据结构：数组+链表+红黑树 // 红黑树是1.8引入

/**
 * The default initial capacity - MUST be a power of two.
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

容量为什么是2的幂次？

无论如何，我们希望元素存放的更均匀。

从后面[hash](#hash(Object key))的实现可以看出来n-1二进制是全1的，这样做与运算就避免了因为该值产生的多余的碰撞。所以相比别的值而言，采用2的幂次能有效提高插入查询等的效率。

put(K key, V value)

发现一篇博文，https://blog.csdn.net/visant/article/details/80045154，里面的图很好地说明了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 ((p = tab[i = (n - 1) & hash]) == null)	// 不存在hash碰撞
        tab[i] = newNode(hash, key, value, null);
    else {	// 存在hash碰撞，这里是采用链地址法
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))	// hash和key都相同，就是更新，不管它是啥类型的节点，反正它是第一个节点
            e = p;
        else if (p instanceof TreeNode)	// 是红黑树节点，调用putTreeVal()
            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);
                    // 链表长度大于某个值时，调用treeifyBin()将链表转红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // hash和key都相同，就是更新
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        ...
    }
    ...
}

首次我们来计算hash值[hash](#hash(Object key))，然后通过tab[i = (n - 1) & hash]找到bucket位置，存储Map.Entry对象（包含键和值）。更具体地，(n - 1) & hash所作的运算其实就是取hash的的后(log_2n)位。也就是取低位哦！

为什么不直接用hash值，而是采用与运算/取低位？

hash值可是32位呢，这么大，tab内存不够的呀~

那为何是按位与而不是取模？取模也可以很好地分散啊~int index =hash%Entry[].length;

按位与比取模效率更高。位运算直接对内存数据进行操作，不需要转成十进制。

具体地，我们可以看反汇编的结果

; c = a & (b-1);  
mov         eax,dword ptr [ebp-8]  
sub         eax,1  
mov         ecx,dword ptr [ebp-4]  
and         ecx,eax  
mov         dword ptr [ebp-0Ch],ecx  
; d = a % b;
mov         eax,dword ptr [ebp-4]  
cdq  
idiv        eax,dword ptr [ebp-8]  
mov         dword ptr [ebp-10h],edx  

可以看到，&操作用了3mov+1and+1sub，而%操作用了2mov+1cdp+1idiv；前者只需5个CPU周期，而后者至少需要26个CPU周期。

插入null如何处理？

hash()会为0，所以值会存在tab[0]的位置上。

hash(Object key)

static final int hash(Object key) {
    int h;	// 是一个32位的int值
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

计算出key的哈希值h，然后将哈希值h无符号右移16位，再与原来的哈希值h做异或^运算。也就是说，现在的低位16是原来的高位16与低位16的异或结果！结合我们找bucket位置的时候是取低位，这样就保证了取的低位里面有所有hash的信息！

get(Object key)

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)	// 是红黑树节点，getTreeNode()
                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;
}

这里和put()方法一样，都是先找到bucket位置，然后进行3部分的判断。

containsKey(Object key)

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

能够get(Object key)，当然能够判断是否包含Object key啦！调用的子方法同get()！

resize()

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {	// 如果oldCap不为0，要么是最大的值，要么就是扩容一倍
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 如果oldCap为0，如果oldThr不为0，这个threshold就是初始容量
        newCap = oldThr;
    else {               // 如果oldThr也为0，那么初始容量就是DEFAULT_INITIAL_CAPACITY
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    
    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) {
            ...
        }
    }
    return newTab;
}

---

下面是红黑树的部分，先放着QAQ，回头看看这个数据结构。

putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v)

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                               int h, K k, V v) {
        Class<?> kc = null;
        boolean searched = false;
        TreeNode<K,V> root = (parent != null) ? root() : this;
        for (TreeNode<K,V> p = root;;) {
            int dir, ph; K pk;
            if ((ph = p.hash) > h)	// 红黑树中根据hash值、key值找结点
                dir = -1;
            else if (ph < h)
                dir = 1;
            else if ((pk = p.key) == k || (k != null && k.equals(pk)))	// 找到则返回此节点
                return p;
            else if ((kc == null &&
                      (kc = comparableClassFor(k)) == null) ||
                     (dir = compareComparables(kc, k, pk)) == 0) {
                if (!searched) {
                    TreeNode<K,V> q, ch;
                    searched = true;
                    if (((ch = p.left) != null &&
                         (q = ch.find(h, k, kc)) != null) ||
                        ((ch = p.right) != null &&
                         (q = ch.find(h, k, kc)) != null))
                        return q;
                }
                dir = tieBreakOrder(k, pk);
            }

            TreeNode<K,V> xp = p;
            if ((p = (dir <= 0) ? p.left : p.right) == null) {	// 没找到时
                Node<K,V> xpn = xp.next;
                TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);	// 创建一个结点
                if (dir <= 0)	 // 比较
                    xp.left = x;
                else
                    xp.right = x;
                xp.next = x;	 // 插入
                x.parent = x.prev = xp;
                if (xpn != null)
                    ((TreeNode<K,V>)xpn).prev = x;
                moveRootToFront(tab, balanceInsertion(root, x));	// 调整
                return null;
            }
        }
    }
}

treeifyBin(tab, hash)

将链表转为红黑树。

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            // 此处才是真正的转为红黑树
            hd.treeify(tab);
    }
}

---

补充内容

解决 hash 冲突的常见方法

a. 链地址法：将哈希表的每个单元作为链表的头结点，所有哈希地址为 i 的元素构成一个同义词链表。即发生冲突时就把该关键字链在以该单元为头结点的链表的尾部。

b. 开放定址法：即发生冲突时，去寻找下一个空的哈希地址。只要哈希表足够大，总能找到空的哈希地址。

c. 再哈希法：即发生冲突时，由其他的函数再计算一次哈希值。

d. 建立公共溢出区：将哈希表分为基本表和溢出表，发生冲突时，将冲突的元素放入溢出表。

线程安全

HahMap不是线程安全的。怎么做能使HashMap线程安全（其实考到了并发包的东西）？

方法一：通过Collections.synchronizedMap()返回一个新的Map，这个新的map就是线程安全的。 这个要求大家习惯基于接口编程，因为返回的并不是HashMap，而是一个Map的实现。

方法二：重新改写了HashMap，具体的可以查看java.util.concurrent.ConcurrentHashMap. 这个方法比方法一有了很大的改进。