HashMap学习记录

HashMap

不管是JDK7还是JDK8，HashMap都是通过链表+数组的结构实现的，JDK8对链表结构做了优化，满足条件会将链表转化成红黑树。HashMap的常用操作是put()方法、get()方法、resize()、hash()方法。

JDK8中的HashMap底层实现

1. new HashMap():

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;   //负载因子，默认值为 0.75。该值与threshold配合使用。
        this.threshold = tableSizeFor(initialCapacity); //扩容的阈值，等于 capacity * loadFactor。即当数组内达到这么多元素时，会触发数组的扩容。
    }

可以发现在执行new操作的时候，仅仅初始化了相关的参数。没有创建动态数组，没有分配数组堆内存。

static final int tableSizeFor(int cap) {
        int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

tableSizeFor函数的目的是得到比传入参数大的最小2的幂次方值。

2. put():

hashMap写入数据的过程如下：

• 计算将插入数据的哈希值，并根据其哈希值计算出插入的数组下标位置
• 若当前桶数组为null，则调用resize()方法进行扩容
• 若没有哈希冲突直接放在对应的数组下标里
• 若存在哈希冲突，且 key 已经存在，就替换掉 value
• 若发生哈希冲突，且发现存放的是红黑树，就将这个节点挂在树上
• 若哈希碰撞后为链表，就添加到链表尾部（尾插法）【jdk7是头插法】；如果链表长度超过阈值（默认为8），就将链表转化为红黑树。

//源码注释学习自：https://zhuanlan.zhihu.com/p/66974753

public V put(K key, V value) {  //提供外部调用的put()方法
	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;
        // 发现动态数组为null则会初始化数组。因此第一次放入值时会在这里初始化数组
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;  
        // 通过hash发现要放入的元素的数组位置为null，则直接把该元素放在这里即可
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //哈希碰撞，节点已存在，替换value
            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;
                }
            }
            // 对应上面节点已存在跳出循环的分支，直接替换value
            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允许键值对为null，null的键值对被放入了桶数组的第0个位置.

3. get():

• 根据key值,hash出在数组中的位置
• 取出指定位置的元素（这时，key的hash值是一样的）
• 如果key也完全一样，则返回该值，查找结束。
• 如果key不一样，判断其后面挂载的是树还是列表
• 如果是树，按照树的方法查找
• 如果是列表，按照列表的方法查找

4. resize():

扩容的过程：

• 将数组的长度变为原来的两倍。
• 将已经hash分布到数组中的所有元素重新计算hash值，分配到新的数组中。

其中第二步的hash是如何操作的？如何寻址？

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

HashMap寻址公式：index = （n-1）& hash

n为动态数组的长度； hash为哈希函数的计算结果。逻辑与操作我们可以理解为hash值的二进制数在(n-1)的二进制数上的求交集操作，记为p。最终得到的结果肯定小于等于(n-1)。

在扩容时，n变为原来的两倍大小，记为m。那在二进制上，m就相当于在n的二进制基础上高位增加了一个1。那么，hash的二进制数和m的二进制数求交集后结果记为q。则除了最高位以外，q和hash值的二进制数在(n-1)的二进制数上的求交集的结果p是一致的。因此，q要么等于p，要么等于p+n。

以上两段的结论简单说来就是：设原来table的长度为a，扩展后变为b，且b=2a。则会将原来table[i]中的元素，经过重hash后，会分拆到新的数组newTable[i]和newTable[i+a]这两个位置上。因此，这样就减少了计算和移动量。

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) {
        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) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        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) {
            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)
                    // 树元素重hash
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    // 略：链表元素重hash
                }
            }
        }
    }
    return newTab;
}

6. HashMap的线程不安全问题

数据覆盖问题

JDK7 JDK8在多线程下进行数据的插入、删除、修改等都可能会出现后结束的线程覆盖了前面线程进行相同操作的数据。

扩容死循环问题

JDK7中会出现链表成环的问题，JDK8对扩容方法进行了优化，得到解决。

JDK7成环原因

    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            //e为空时循环结束
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                // 成环的代码主要是在这三行代码
                // 首先插入是从头开始插入的
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

–》这里的节点插入采用了头插法，导致与原链表的节点顺序相反
–》table 是共享的，table 里面的元素也是共享的，while 循环都直接修改 table 里面的元素的 next 指向，导致指向混乱。

JDK8如何解决的

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

–》JDK8 是等链表整个 while 循环结束后，才给数组赋值，此时使用局部变量 loHead 和 hiHead 来保存链表的值，因为是局部变量，所以多线程的情况下，肯定是没有问题的。

–》根据resize()扩容方法的分析，重新hash并计算出的索引位置可能与原来相等，也可能发生变化（具体看扩容部分的分析）。需要loHead 和 hiHead 两个新老值来保存链表。

7 .HashMap重写hashCode()和equals() 方法

首先了解下hashcode：通过对象的内部地址(也就是物理地址)转换成一个整数，然后该整数通过hash函数的算法就得到了hashcode。

hashCode()方法是用来在散列存储结构中确定对象的存储地址的 ( 用hashcode来代表对象在hash表中的位置 ) , 根据 key 的 hashcode 值生成数组下标（以空间换时间）。就是说，hashCode()方法来确定对象在table的位置。

equals()方法：两个对象在hash值相等时通过equals（）方法判断两个对象是否相等。如果不重写，从object继承的hashcode和equits方法都是比较的内存地址，由于自定义的两个对象，内存地址肯定不一致，肯定不相等。

在HashMap表的键部分存放自定义对象时，一定要重写hashCode() 和equals()方法，来覆盖Object里的同名方法

HashMap面试题，看这一篇就够了！
HashMap源码详解
大多数人不知道的：HashMap链表成环的原因和解决方案