hashmap专题

HashMap在JDK1.7和JDK1.8中有哪些不同？HashMap的底层实现（重点）

JDK1.8之前
采用数组+链表实现，当产生hash冲突就将数据放入链表中

JDK1.8之后
相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。

hashmap1.8为什么使用红黑树不使用AVL

AVL的查找效率跟红黑树的查找效率差不多，但是红黑树的插入结点和删除结点操作效率要高于AVL，AVL插入结点要保证左右子树的的平衡因子在-1,0,1，插入结点的时候要进行LL,RR,LR,RL平衡调整比较耗费时间。

1.8之前hashmap的put和get原理（重点）

put原理

  // 将“key-value”添加到HashMap中 
  public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)// 若“key为null”，则将该键值对添加到table[0]中。 
            return putForNullKey(value); 
      // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。 
        int hash = hash(key);//获取key的hash值
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;

            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
             // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
   // 若“key”对应的键值对不存在，则将“key-value”添加到table中 
        modCount++;
   //将key-value添加到table[i]处
        addEntry(hash, key, value, i);
        return null;
    }


// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置 
	private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
 // 如果没有存在key为null的键值对，则直接添加到table[0]处! 
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

• key为null，则返回一个putForNullKey()，在该方法中去遍历table[0]对应的链表，如果entry.key==null，就使用value替换到该entry中oldvalue并返回oldvalue；如果table[0]==null或者entry.key!=null，执行addEntry()，添加一个key=null的entry在头结点位置；
• key不为null，则去table[hash(key)&table.length-1]得到table的下标，去遍历table[i]对应的链表，如果链表的entry.key==key，value替换该entry中oldvalue并返回oldvalue;如果table[i]==null或者单链表中entry.key!=key，那么执行addEntry()，创建一个entry添加到头结点；

get原理

  // 获取key对应的value 
 public V get(Object key) {
        if (key == null)
            //如果key为null,调用getForNullKey()
            return getForNullKey();
        //key不为null,调用getEntry(key);
        Entry<K,V> entry = getEntry(key);
        return null == entry ? null : entry.getValue();
}
 //当key为null时,获取value
    private V getForNullKey() {
        if (size == 0) {
            return null;//链表为空,返回null
        }
    //链表不为空,将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

//key不为null,获取value
final Entry<K,V> getEntry(Object key) {
        if (size == 0) {//判断链表中是否有值
         //链表中没值,也就是没有value
            return null;
        }
       //链表中有值,获取key的hash值 
        int hash = (key == null) ? 0 : hash(key);
        // 在“该hash值对应的链表”上查找“键值等于key”的元素 
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //判断key是否相同
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;//key相等,返回相应的value
             }
        return null;//链表中没有相应的key
    }

• key为null，则返回一个getForNullKey()，在该方法table[0]对应的链表中去查找entry.key=null所对应的value；
• key不为null，则执行getEntry()，在该方法table[key.hash&table.length-1]，去table[i]所对应链表中查找entry.key==key从而得到value;

1.8之后hashmap的put原理

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value(put 传 false)
     * @param evict if false, the table is in creation mode.(put 传 true)
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K,V>[] tab;  //缓存底层数组用,都是指向一个地址的引用
        Node<K,V> p;      //插入数组的桶i处的键值对节点
        int n;            //底层数组的长度
        int i;            //插入数组的桶的下标
        //刚开始table是null或空的时候，初始化个默认的table；为tab和n赋值，tab指向底层数组，n为底层数组的长度
        if ((tab = table) == null || (n = tab.length) == 0){
            n = (tab = resize()).length;
        }
        //(n - 1) & hash：根据hash值算出插入点在底层数组的桶的位置，即下标值；为p赋值，也为i赋值（不管碰撞与否，都已经赋值了）
        //如果在数组上，没有发生碰撞，即当前要插入的位置上之前没有插入过值，则直接在此位置插入要插入的键值对
        if ((p = tab[i = (n - 1) & hash]) == null){
            tab[i] = newNode(hash, key, value, null);//插入的节点的next属性是null
        } else {    //发生碰撞，即当前位置已经插入了值
            Node<K,V> e;    //中间变量吧，跟冒泡排序里面的那个中间变量似的，起到个值交换的作用
            K k;            //同上
            //hash值相同，key也相同，那么就是更新这个键值对的值。同 jdk 1.7
            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))){ //注意在这个if内【e != null】
                e = p;//这地方，e = p  他们两个都是指向数组下标为i的地方，在这if else if else结束之后，再把节点的值value给更新了
            } else if (p instanceof TreeNode){  //这个树方法可能会返回null。
                //jdk 1.8引入了红黑树来处理碰撞，上面判断p的类型已经是树结构了，
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//如果是，则走添加树的方法。
            } else {    //注意在这个else内，当为添加新节点时，【e == 】；更新某个节点时，就不是null
                for (int binCount = 0; ; ++binCount) {//还未形成树结构，还是jdk 1.7的链表结构
                    //差别就是1.7:是头插法，后来的留在数组上，先来的链在尾上；1.8:是先来的就留在数组上，后来的链在尾上
                    //判断p.next是否为空，同时为e赋值，若为空，则p.next指向新添加的节点，这是在链表长度小于7的时候
                    if ((e = p.next) == null) {
                        //这个地方有个不好理解的地方：在判断条件里面，把e指向p.next，也就是说现在e=null而不是下下一行错误的理解。
                        //这也就解释了更新的时候，返回oldValue，新建的时候，是不在那地方返回的。
                        p.next = newNode(hash, key, value, null);//e = p.next,p.next指向新生成的节点，也就是说e指向新节点（错误）
                        //对于临界值的分析：
                        //假设此次是第六次，binCount == 6,不会进行树变，当前链表长度是7；下次循环。
                        //binCount == 7，条件成立，进行树变，以后再put到这个桶的位置的时候，这个else就不走了，走中间的那个数结构的分叉语句啦
                        //这个时候，长度为8的链表就变成了红黑树啦
                        if (binCount >= TREEIFY_THRESHOLD - 1){// -1 for 1st //TREEIFY_THRESHOLD == 8
                            treeifyBin(tab, hash);
                        }
                        break;//插入新值或进行树变后，跳出for循环。此时e未重定向，还是指向null，虽然后面p.next指向了新节点。
                        //但是，跟e没关系。
                    }
                    //如果在循环链表的时候，找到key相同的节点，那么就跳出循环，就走不到链表的尾上了。
                    // e已经在上一步已经赋值了，且不为null,也会跳出for循环，会在下面更新value的值
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
                        break;
                    }
                    //这个就是p.next也就是e不为空，然后，还没有key相同的情况出现，那就继续循环链表，
                    // p指向p.next也就是e，继续循环，继续，e=p.next
                    p = e;
                    //直到p.next为空，添加新的节点；或者出现key相等，更新旧值的情况才跳出循环。
                }
            }
            //经过上面if else if else之后，e在新建节点的时候，为null；更新的时候，则被赋值。在树里面处理putTreeVal（）同样如此，
            if (e != null) { // existing mapping for key//老外说的对，就是只有更新的时候，才走这，才会直接return oldValue
                V oldValue = e.value;
                //onlyIfAbsent 这个在调用hashMap的put()的时候，一直是false，那么下面更新value是肯定执行的
                if (!onlyIfAbsent || oldValue == null){
                    e.value = value;
                }
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold){
            resize();
        }
        afterNodeInsertion(evict);
        return null;
    }

• 判断node==null，如果null，进行resize()扩容；
• 计算table[key.hash&table.length-1]，添加数据（分为多种情况）：
• 当table[i]==null，直接添加一个链表的头结点；
• 当table[i] instanceof treenode，添加一个树节点；
• 当table[i]==node，继续添加node，当链表长度>=treeify_threshold-1，就调用treeifyBin()将链表转成红黑树

hahsmap为什么不是线程安全的（1.8之前的）

有两个线程A和B都要调用put()往hashmap中放k-v， 线程A和线程B他们的key.hash相同即发生了hash冲突，线程A先执行往table[i]==null里面插入元素，线程A正进行到这一步时被挂起来了，线程B执行，线程B成功往table[i]中插入元素，此时线程A继续执行，线程A往table[i]中插入元素（其实table[i]!=null）但是线程A并不知道所以于是就将线程B的元素覆盖掉了造成线程不安全

HashMap的初始容量，加载因子，扩容增量是多少？

hashmap初试容量是16，装载因子是0.75，当16*0.75=12，当>12时就进行扩容，扩容为2n原来的两倍。

为什么hashmap的装载因子是0.75呢？

• 装载因子太小，hashmap需要频繁进行扩容且空间利用率极低；
• 装载因子太大，hashmap虽然空间利用率提高了，但是很容易产生hash冲突；0.75是空间效率和时间效率达到平衡的选择。

hashmap的时间复杂度（重点）

理想情况下，hashmap的时间复杂度为O(1)，根据key.hash = (h = k.hashCode()) ^ (h >>>16)可以得到key在数组中的位置，这刚好就是数组的高效查询时间复杂度O(1)，当有链表的时候时间复杂度变为O(n)，当有红黑树的时候时间复杂度变为O(logn)

hashmap解决hash冲突方法

• 使用链地址（拉链法）法来链接相同hash值的数据（hashmap使用该方法）
• 线性探测再散列法
• 二次线性探测再散列法

为什么HashMap中String、Integer这样的包装类适合作为K？

都是final类型，具有不可变性，内部都重写了equals()、hashCode()等方法，保证key的不可更改性，不会存在获取hash值不同的情况。
遵守了HashMap内部的规范。

如果使用Object作为HashMap的Key，应该怎么办呢？

答：重写hashCode()和equals()方法
重写hashCode()是因为需要计算value的存储位置
重写equals()方法，目的是为了保证key在哈希表中的唯一性；

HashMap 的长度为什么是2的幂次方

• 往hashmap中插入数据时，先计算key的hash值。key.hash = (h = k.hashCode()) ^ (h >>>16)
• 计算bucket数组的位置，index = key.hash & (table.length-1)，找到元素被存放在bucket数组中的位置。
• 这其中length-1转化为二进制是1111…的形式再与key.hash与运算效率高，提高hashmap的查询效率使数据分部更加均匀减少hash冲突，不浪费空间。

HashMap 与 HashTable 有什么区别？（重点）

hashmap	hashtable
不是线程安全的	是线程安全的使用synchronized实现线程安全
key可以为null	key和value都不能为null
初试容量为16，装载因子0.75，当16*0.75=12，>12之后每次扩容都是2n	初试容量是11，之后每次扩容都是2n+1
1.8之前使用数组+链表；1.8之后使用数组+链表（长度>8）+红黑树	hashtable类似于hashmap1.8之前的机构数组+链表
hashmap效率高	hashtable已经被淘汰了不使用了

HashMap 和 ConcurrentHashMap 的区别

HashMap	ConcurrentHashMap
1.8之前采用数组+链表实现；1.8之后采用数组+链表（长度>8）转变为红黑树实现	1.8之前采用segments数组实现每个segment相当于一个hashmap，里面有个hashentry数组它既是key-value链表的头结点；1.8之后摒弃了segemnts的概念，使用node数组+链表（长度>8）转变为红黑树实现
hashmap不是线程安全的，多线程情况下扩容会出现死循环的问题	1.8之前使用segemnts分段锁实现线程安全，每个segment都是一把锁多线程获取各自的segemnt锁进行同步操作；1.8之后使用node数组+链表+红黑树实现同步操作使用CAS+synchronized实现

hashmap1.8的resize详解

为什么需要resize()

为了解决hash冲突导致的链化带来的查询效率问题所以需要进行扩容，扩容会缓解该问题

hashmap什么时候进行resize

• 当hashmap的table的长度达到table.length*loadfactor=16*0.75=12时候进行resize();
• 当new一个hashmap的时候，调用put的方法的时候会进行判断table==null||table.length==0也会进行resize；

resize原理

1 final Node<K,V>[] resize() {
2        Node<K,V>[] oldTab = table;  //oldTab扩容之前的table
3        int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldCap扩容之前的table的长度
4        int oldThr = threshold;//oldThr扩容之前的阈值
5        int newCap, newThr = 0; //newCap扩容之后的table长度，newThr扩容之后的阈值
		//如果oldCap>0,说明hashmap中的table已经被初始化了，是一次正常的扩容
6        if (oldCap > 0) {
7            if (oldCap >= MAXIMUM_CAPACITY) { //扩容之前的table容量达到最大值，设置阈值为integer的最大值
8                threshold = Integer.MAX_VALUE;
9                return oldTab;
10            }
		//扩容之前的table容量<<1实现翻倍赋值给newCap，newCap<最大值 并且 扩容之前的table容量>=16，则扩容之前的阈值翻一倍赋值给newThr
11            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)  
14                newThr = oldThr << 1; 
15        }
			     //oldCap==0,oldThr>0,newCap=oldThr
16        else if (oldThr > 0) 
17            newCap = oldThr;
18        else { //oldCap==0，oldThr==0,则扩容之后的table容量是16，扩容之后的阈值就是12          
19            newCap = DEFAULT_INITIAL_CAPACITY;//16
20            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
21        }
22        if (newThr == 0) {
23            float ft = (float)newCap * loadFactor;
24            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
25                      (int)ft : Integer.MAX_VALUE);
26        }
27        threshold = newThr;
28        @SuppressWarnings({"rawtypes","unchecked"})
29            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
30            table = newTab;
		  //如果扩容table容量不是null
31        if (oldTab != null) {
32            for (int j = 0; j < oldCap; ++j) {
33                Node<K,V> e;
		  //数组里面的结点不是null,结点是单链表结点还是红黑树结点要判断
34                if ((e = oldTab[j]) != null) {
35                    oldTab[j] = null; //方便jvm的gc进行垃圾回收
36                    if (e.next == null)//如果数组中只有一个节点，没有发生hash冲突，直接计算出扩容之后的数组位置将节点放进去
37                        newTab[e.hash & (newCap - 1)] = e;
38                    else if (e instanceof TreeNode)//数组中的结点是树结点
39                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
40                    else { 
41                        Node<K,V> loHead = null, loTail = null;//高位链表，低位链表
42                        Node<K,V> hiHead = null, hiTail = null;//高位链表，低位链表
43                        Node<K,V> next;
44                        do {
45                            next = e.next;
46                            if ((e.hash & oldCap) == 0) {
47                                if (loTail == null)
48                                    loHead = e;
49                                else
50                                    loTail.next = e;
51                                loTail = e;
52                            }
53                            else {
54                                if (hiTail == null)
55                                    hiHead = e;
56                                else
57                                    hiTail.next = e;
58                                hiTail = e;
59                            }
60                        } while ((e = next) != null);
61                        if (loTail != null) {
62                            loTail.next = null;
63                            newTab[j] = loHead;
64                        }
65                        if (hiTail != null) {
66                            hiTail.next = null;
67                            newTab[j + oldCap] = hiHead;
68                        }
69                    }
70                }
71            }
72        }
73        return newTab;
74    }