Java学习笔记(8)：Map接口和常用方法（2）

HashMap 底层机制

• (k,v)是一个Node 实现了 Map.Entry<K,V>，查看 HashMap 的源码可以看到

• jdk7.0的 HashMap 底层实现【数组+链表】，jdk8.0底层【数组+链表+红黑树】

HashMap 扩容细节

扩容机制和HashSet 相同

1. HashMap 底层维护了Node 类型的数组 table，默认为null
2. 当创建对象时，将加载因子（loadfactor）初始化为0.75
3. 当添加 key-val 时，通过key 的哈希值得到在table中的索引，然后判断该索引处是否有元素，如果没有元素则直接添加。如果该索引处有元素，继续判断该元素的 key 是否和准备加入的 key 相等，如果相等，则直接替换 val；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容
4. 第1次添加，则需要扩容 table 容量为16，临界值（threshold）为12（16*0.75）
5. 以后再扩容，则需要扩容 table 容量为原来的2倍，临界值为原来的2倍，即24，以此类推
6. 在Java8中，如果一条链表元素超过TREEIFY_THRESHOLD（默认为8），并且 table 的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树）

源码分析

	HashMap hashMap = new HashMap();
	hashMap.put("java",10);
	hashMap.put("php",10);
	hashMap.put("java",20);

• 执行put 调用 hash 方法，计算key 的 hash值 (h = key.hashCode() ^ (h >>> 16));

public V put(K key, V value) {	//K="java" value=10
return putVal(hash(key), key, value, false, true);
}

• 执行 putVal 方法

    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 数组为null，或者 length=0，就扩容到16
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //取出hash值对应的 table表的索引位置的Node，如果为null，就直接把加入k-v
        //，创建成一个Node 加入到该位置即可
        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 &&	//如果 table的索引位置的key的hash  和 新key的hash值 相同，
                //并满足table现有的结点的key和准备添加的key是同一个对象 || equals返回真）
                //就认为不能加入新的k-v
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理
                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);
                        //加入后，判断当前链表的个数，是否已经到8个，到8个就
                        //调用 treeifyBin 方法进行红黑树的转换
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&	//如果在循环比较过程中，发现有相同，就只是替换value
                        ((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;	//替换key对应的value
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;//每增加一个Node，就size++
        if (++size > threshold)//如果size > 临界值，就扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

• 关于树化（转成红黑树）

    //如果table 为null，或者大小还没有到64，则暂时不树化，而是进行扩容
	//否则才会真正的树化
	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);
        }
    }