HashMap底层原理及一些问题归纳

最新推荐文章于 2024-04-24 23:01:15 发布

刘记清汤圆

最新推荐文章于 2024-04-24 23:01:15 发布

阅读量92

点赞数 1

分类专栏： Java基础文章标签： hashmap java 数据结构

本文链接：https://blog.csdn.net/m0_43394686/article/details/117222621

版权

Java基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

这篇博客详细解析了HashMap在JDK1.7和1.8中的不同之处，包括扩容策略、元素插入位置以及红黑树的引入。在1.7中，扩容发生在元素添加前，新元素加在链表头部；而在1.8中，扩容发生在添加后，新元素加在尾部，并在链表过长时转为红黑树。此外，博客还介绍了HashMap的加载因子和扩容机制，以及get和put操作的实现原理。JDK1.8的改进显著提高了查找效率，减少了哈希碰撞带来的性能影响。

摘要由CSDN通过智能技术生成

hashmap 1.7扩容是发生在元素添加之前 1.8扩容是发生在元素添加之后

hashmap 1.7 和 1.8 区别在增加新元素时 1.7加在头部 1.8加在尾部且超过预值会转为红黑树

hashmap的元素下标计算是通过key的hashcode 二进制向右移动一位再与原本的hashcode 进行异或运算得到的值再将得到的值与 hashmap中数组长度-1 进行与（&）运算从而得到元素要插入的下标位置

在这里插入图片描述

H  1010 0101

15 0000 1111

&

   0000 0101

H >> 1 0000 0000 1010 0101

H    1010 0101 0000 0000

^    1010 0101 1010 0101



15    0000 0000 0000 1111

&    0000 0000 0000 0101

注：这也是为什么Hashmap的长度只能取2的指数的长度

实现原理：先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率

加载因子（默认0.75）：为什么需要使用加载因子，为什么需要扩容呢？

因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率

HashMap如何getValue值

public V get(Object key) {

    Node<K,V> e;

    return (e = getNode(hash(key), key)) == null ? null : e.value;

}

  /**

 * Implements Map.get and related methods

 *

 * @param hash hash for key

 * @param key the key

 * @return the node, or null if none

 */

final Node<K,V> getNode(int hash, Object key) {

    Node<K,V>[] tab;//Entry对象数组

Node<K,V> first,e; //在tab数组中经过散列的第一个位置

int n;

K k;

/*找到插入的第一个Node，方法是hash值和n-1相与，tab[(n - 1) & hash]*/

//也就是说在一条链上的hash值相同的

    if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {

/*检查第一个Node是不是要找的Node*/

        if (first.hash == hash && // always check first node

            ((k = first.key) == key || (key != null && key.equals(k))))//判断条件是hash值要相同，key值要相同

            return first;

  /*检查first后面的node*/

        if ((e = first.next) != null) {

            if (first instanceof TreeNode)

                return ((TreeNode<K,V>)first).getTreeNode(hash, key);

			/*遍历后面的链表，找到key值和hash值都相同的Node*/

            do {

                if (e.hash == hash &&

                    ((k = e.key) == key || (key != null && key.equals(k))))

                    return e;

            } while ((e = e.next) != null);

        }

    }

    return null;

}

get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就遍历后面的链表找到相同的key值返回对应的Value值即可

HashMap如何put(key，value)

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

 * @param evict if false, the table is in creation mode.

 * @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; 

int n, i;

    if ((tab = table) == null || (n = tab.length) == 0)

        n = (tab = resize()).length;

/*如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置*/

    if ((p = tab[i = (n - 1) & hash]) == null)

        tab[i] = newNode(hash, key, value, null);

/*表示有冲突,开始处理冲突*/

    else {

        Node<K,V> e; 

    K k;

/*检查第一个Node，p是不是要找的值*/

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

	       //如果冲突的节点数已经达到8个，看是否需要改变冲突节点的存储结构，
	       　//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行

               //resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树

                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

                        treeifyBin(tab, hash);

                    break;

                }

	/*如果有相同的key值就结束遍历*/

                if (e.hash == hash &&((k = e.key) == key || (key != 	null && key.equals(k))))

                    break;

                p = e;

            }

        }

/*就是链表上有相同的key值*/

        if (e != null) { // existing mapping for key，就是key的Value存在

            V oldValue = e.value;

            if (!onlyIfAbsent || oldValue == null)

                e.value = value;

            afterNodeAccess(e);

            return oldValue;//返回存在的Value值

        }

    }

    ++modCount;

 /*如果当前大小大于门限，门限原本是初始容量*0.75*/

    if (++size > threshold)

        resize();//扩容两倍

    afterNodeInsertion(evict);

    return null;

}

下面简单说下添加键值对put(key,value)的过程：

判断键值对数组tab[]是否为空或为null，否则以默认大小resize()；
根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3
判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理

HasMap的扩容机制resize()

构造hash表时，如果不指明初始大小，默认大小为16（即Node数组大小16），如果Node[]数组中的元素达到（填充比*Node.length）重新调整HashMap大小变为原来2倍大小,扩容很耗时

/**

 * Initializes or doubles table size.  If null, allocates in

 * accord with initial capacity target held in field threshold.

 * Otherwise, because we are using power-of-two expansion, the

 * elements from each bin must either stay at same index, or move

 * with a power of two offset in the new table.

 *

 * @return the table

 */

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;

        }

/*把新表的长度设置为旧表长度的两倍，newCap=2*oldCap*/

        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

                 oldCap >= DEFAULT_INITIAL_CAPACITY)

      /*把新表的门限设置为旧表门限的两倍，newThr=oldThr*2*/

            newThr = oldThr << 1; // double threshold

    }

 /*如果旧表的长度的是0，就是说第一次初始化表*/

    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;//把新表赋值给table

    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)//说明这个node没有链表直接放在新表的e.hash & (newCap - 1)位置

                    newTab[e.hash & (newCap - 1)] = e;

                else if (e instanceof TreeNode)

                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

/*如果e后边有链表,到这里表示e后面带着个单链表，需要遍历单链表，将每个结点重*/

                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;//记录下一个结点

		  //新表是旧表的两倍容量，实例上就把单链表拆分为两队，
		  　//e.hash&oldCap为偶数一队，e.hash&oldCap为奇数一对

                        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) {//lo队不为null，放在新表原位置

                        loTail.next = null;

                        newTab[j] = loHead;

                    }

                    if (hiTail != null) {//hi队不为null，放在新表j+oldCap位置

                        hiTail.next = null;

                        newTab[j + oldCap] = hiHead;

                    }

                }

            }

        }

    }

    return newTab;

}

JDK1.8使用红黑树的改进

在java jdk8中对HashMap的源码进行了优化，在jdk7中，HashMap处理“碰撞”的时候，都是采用链表来存储，当碰撞的结点很多时，查询时间是O（n）。

在jdk8中，HashMap处理“碰撞”增加了红黑树这种数据结构，当碰撞结点较少时，采用链表存储，当较大时（>8个），采用红黑树（特点是查询时间是O（logn））存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）

问题分析：

你可能还知道哈希碰撞会对hashMap的性能带来灾难性的影响。如果多个hashCode()的值落到同一个桶内的时候，这些值是存储到一个链表中的。最坏的情况下，所有的key都映射到同一个桶中，这样hashmap就退化成了一个链表——查找时间从O(1)到O(n)。

随着HashMap的大小的增长，get()方法的开销也越来越大。由于所有的记录都在同一个桶里的超长链表内，平均查询一条记录就需要遍历一半的列表。

JDK1.8HashMap的红黑树是这样解决的：

如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。

它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。