深入理解HashMap源码

文章目录

  • HashMap简介
  • 源码分析
    • 关键参数
    • 获取数组下标
    • put方法
    • resize扩容过程
      • jdk1.7的扩容实现
      • jdk1.8的扩容实现
    • get()方法
    • remove()方法
  • 总结


关于HashMap,一直都是一个非常热门的话题,只要你出去面试,一定少不了它!
本文主要结合 JDK1.7 和 JDK1.8 的区别,就HashMap的数据结构和实现功能,进行深入探讨。

HashMap简介

在程序编程的时候,HashMap是一个使用非常频繁的容器类,它允许键值都放入null元素(但是键位置只有一个为null)。

除该类方法未实现同步外,其余跟Hashtable大致相同,但跟TreeMap不同,该容器不保证元素顺序,根据需要该容器可能会对元素重新哈希,元素的顺序也会被重新打散,因此不同时间迭代同一个HashMap的顺序可能会不同。

HashMap容器,实质还是一个哈希数组结构,在元素插入的时候,存在hash冲突的可能性。

解决hash冲突有哪些方式?

1、开放地址方式(当发生hash冲突时,就继续以此继续寻找,直到找到没有冲突的hash值)。

2、拉链方式(将冲突的元素放入链表), HashMap采用的就是第二种方式,拉链法。

  • 在jdk1.7中,HashMap主要是由数组+链表组成,当发生hash冲突的时候,就将冲突的元素放入链表中。
  • 从jdk1.8开始,HashMap主要是由数组+链表+红黑树实现的,相比jdk1.7而言,多了一个红黑树实现。

TIP:将链表转换成红黑树前会判断,即使阈值大于8,但是数组长度小于64,此时并不会将链表变成红黑树,而是选择进行数组扩容。
这样做的目的是因为数组比较小,尽量避开红黑树结构,这种情况下变成为红黑树结构,反而会降低效率,因为红黑树需要进行左旋,右旋,变色这些操作来保持平衡。同时数组长度小于64时,搜索时间相对要快些。综上所述为了提高性能和减少搜索时间,底层在阈值大于8并且数组长度大于64时,链表才会转换为红黑树,具体可以参考treeifyBin方法。

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)
        // 如果桶数量小于64,直接扩容而不用树化
        // 因为扩容之后,链表会分化成两个链表,达到减少元素的作用
        // 当然也不一定,比如容量为4,里面存的全是除以4余数等于3的元素
        // 这样即使扩容也无法减少链表的长度
        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);
    }
}

HashMap有哪些特点?

  • 存储无序;
  • 键和值位置都可以为null,但是键位置只能一个为null;
  • 键位置的唯一的,底层的数据结构控制的;
  • 从 jdk1.8 开始,HashMap主要是由数组+链表+红黑树实现的;
  • 阈值大于8并且数组长度大于64时,链表才会转换为红黑树。

源码分析

关键参数

  • table:一个哈希桶数组,键值对就存放在里面。

  • size:表示实际存在的键值对数量。

  • modCount:记录修改次数。

  • threshold:表示容器所能容纳的key-value对极限。

  • loadFactor:负载因子。

    transient Node<K,V>[] table;

    transient int size;

    transient int modCount;

    int threshold;
 
    final float loadFactor;

HashMap是一个用于存储Key-Value键值对的集合,每一个键值对也叫做Node(在Java7叫Entry,在Java8中叫Node)。这些个键值对(Node)分散存储在一个数组当中,这个数组就是HashMap的主干。

每一个节点都会保存自身的hash、key、value以及下个节点。

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

两个参数可以影响HashMap的性能:初始容量(inital capacity)和负载因子(load factor)

初始容量(inital capacity):指table的初始长度length(默认值是16)。

负载因子(load factor):指自动扩容的临界值(默认值是0.75)。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;

thresholdHashMap所能容纳的最大数据量的Node(键值对)个数,计算公式threshold = capacity * Load factor。当entry的数量超过capacity*load_factor时,容器将自动扩容并重新哈希,扩容后的HashMap容量是之前容量的两倍,所以数组的长度总是2的n次方。

获取数组下标

不管增加、删除还是查找键值对,定位到数组的位置都是很关键的第一步,打开hashMap的任意一个增加、删除、查找方法,从源码可以看出,通过key获取数组下标,主要做了3步操作,其中length指的是容器数组的大小。

深入理解HashMap源码_第1张图片

源码部分

/**获取hash值方法*/
static final int hash(Object key) {
     int h;
     // h = key.hashCode() 为第一步 取hashCode值(jdk1.7)
     // h ^ (h >>> 16)  为第二步 高位参与运算(jdk1.7)
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//jdk1.8
}
/**获取数组下标方法*/
static int indexFor(int h, int length) {
	//jdk1.7的源码,jdk1.8没有这个方法,但是实现原理一样的
     return h & (length-1);  //第三步 取模运算
}

put方法

HashMap数组每一个元素的初始值都是Null。

img

调用put方法会发生什么呢?

比如调用hashMap.put("apple", 0) ,插入一个 Key 为apple的元素。这时候我们需要利用一个哈希函数来确定 Entry 的插入位置(index):index = Hash(“apple”)

假定最后计算出的index是2,那么结果如下:

img

但是,因为HashMap的长度是有限的,当插入的 Entry 越来越多时,再完美的 Hash 函数也难免会出现 index 冲突的情况。比如下面这样:

深入理解HashMap源码_第2张图片

这时候该怎么办呢?我们可以利用链表来解决。

HashMap数组的每一个元素不止是一个Entry对象,也是一个链表的头节点。每一个 Entry 对象通过 Next 指针指向它的下一个Entry节点。

当新来的Entry映射到冲突的数组位置时,只需要插入到对应的链表即可。

深入理解HashMap源码_第3张图片

  • java8 之前是头插法,就是说新来的值会取代原有的值,原有的值就顺推到链表中去,就像上面的例子一样,因为写这个代码的作者认为后来的值被查找的可能性更大一点,提升查找的效率。

  • 在 java8 之后,都是所用尾部插入了。

为什么 java8 之后为什么采用尾插法呢?

假如我们现在往一个容量大小为2的 hashMap 中 put 两个值,负载因子是0.75是不是我们在put第二个的时候就会进行resize? 因为2 * 0.75 = 1 所以插入第二个就要resize了。

现在我们要在容量为2的容器里面用不同线程插入A,B,C,假如我们在resize之前打个断点,那意味着数据都插入了但是还没resize那扩容前可能是这样的。

我们可以看到链表的指向A->B->C

A的下一个指针是指向B的

深入理解HashMap源码_第4张图片

因为resize的赋值方式,也就是使用了单链表的头插入方式,同一位置上新元素总会被放在链表的头部位置

在旧数组中同一条Entry链上的元素,通过重新计算索引位置后,有可能被放到了新数组的不同位置上。

就可能出现下面的情况,大家发现问题没有?

B的下一个指针指向了A

深入理解HashMap源码_第5张图片

一旦几个线程都调整完成,就可能出现环形链表

深入理解HashMap源码_第6张图片

如果这个时候去取值,悲剧就出现了——Infinite Loop。

因为java8之后链表有红黑树的部分,大家可以看到代码已经多了很多if else的逻辑判断了,红黑树的引入巧妙的将原本 O(n) 的时间复杂度降低到了 O(logn)。

使用头插会改变链表的上的顺序,但是如果使用尾插,在扩容时会保持链表元素原本的顺序,就不会出现链表成环的问题了。

就是说原本是A->B,在扩容后那个链表还是A->B

深入理解HashMap源码_第7张图片

Java7在多线程操作HashMap时可能引起死循环,原因是扩容转移后前后链表顺序倒置,在转移过程中修改了原来链表中节点的引用关系。

Java8在同样的前提下并不会引起死循环,原因是扩容转移后前后链表顺序不变,保持之前节点的引用关系。

那是不是意味着Java8就可以把HashMap用在多线程中呢?

我认为即使不会出现死循环,但是通过源码看到put/get方法都没有加同步锁,多线程情况最容易出现的就是:无法保证上一秒put的值,下一秒get的时候还是原值,所以线程安全还是无法保证。

resize扩容过程

在说jdk1.8的HashMap动态扩容之前,我们先来了解一下jdk1.7的HashMap扩容实现,因为jdk1.8代码实现比Java1.7复杂了不止一倍,主要是Java1.8引入了红黑树设计,但是实现思想大同小异!

jdk1.7的扩容实现

深入理解HashMap源码_第8张图片

源码部分

/**
  * JDK1.7扩容方法
  * 传入新的容量
  */
void resize(int newCapacity) {
    //引用扩容前的Entry数组
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
	//扩容前的数组大小如果已经达到最大(2^30)了
    if (oldCapacity == MAXIMUM_CAPACITY) {
		//修改阈值为int的最大值(2^31-1),这样以后就不会扩容了
        threshold = Integer.MAX_VALUE;
        return;
    }
	//初始化一个新的Entry数组
    Entry[] newTable = new Entry[newCapacity];
	//将数据转移到新的Entry数组里,这里包含最重要的重新定位
    transfer(newTable);
	//HashMap的table属性引用新的Entry数组
    table = newTable;
    threshold = (int) (newCapacity * loadFactor);//修改阈值
}

jdk1.7扩容总结: newTable[i]的引用赋给了e.next,也就是使用了单链表的头插入方式,同一位置上新元素总会被放在链表的头部位置;这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话),这一点和Jdk1.8有区别。在旧数组中同一条Entry链上的元素,通过重新计算索引位置后,有可能被放到了新数组的不同位置上。

jdk1.8的扩容实现

深入理解HashMap源码_第9张图片

源码如下:

final Node<K,V>[] resize() {
	//引用扩容前的node数组
        Node<K,V>[] oldTab = table;
	//旧的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
	//旧的阈值
        int oldThr = threshold;
	//新的容量、阈值初始化为0
        int newCap, newThr = 0;
        if (oldCap > 0) {
		//如果旧容量已经超过最大容量,让阈值也等于最大容量,以后不再扩容
                threshold = Integer.MAX_VALUE;
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
	    // 没超过最大值,就扩充为原来的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
		//如果旧容量翻倍没有超过最大值,且旧容量不小于初始化容量16,则翻倍
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
	    //初始化容量设置为阈值
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
	    //0的时候使用默认值初始化
            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;
		    //如果e没有next节点,证明这个节点上没有hash冲突,则直接把e的引用给到新的数组位置上
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
			//!!!如果是红黑树,则进行分裂
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else {
		        // 链表优化重hash的代码块
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
			//从这条链表上第一个元素开始轮询,如果当前元素新增的bit是0,则放在当前这条链表上,如果是1,则放在"j+oldcap"这个位置上,生成“低位”和“高位”两个链表
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
				 //元素是不断的加到尾部的,不会像1.7里面一样会倒序
                                    loTail.next = e;
				//新增的元素永远是尾元素
                                loTail = e;
                            }
                            else {
				//高位的链表与低位的链表处理逻辑一样,不断的把元素加到链表尾部
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
			//低位链表放到j这个索引的位置上
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
			//高位链表放到(j+oldCap)这个索引的位置上
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
}

get()方法

get(Object key)方法根据指定的key值返回对应的value,getNode(hash(key), key))得到相应的Node对象e,然后返回e.value。因此getNode()是算法的核心。

源码部分:

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

通过hash值和key获取节点Node方法,源码部分:

    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) {
            //1、判断第一个元素是否与key匹配
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                //2、判断链表是否红黑树结构
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                //3、如果不是红黑树结构,直接循环判断
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

在红黑树中找到指定k的TreeNode,源码部分:

/**
  * 这里面情况分很多中,主要是因为考虑了hash相同但是key值不同的情况,查找的最核心还是落在key值上
  */
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
		//判断要查询元素的hash是否在树的左边
                if ((ph = p.hash) > h)
                    p = pl;
		//判断要查询元素的hash是否在树的右边
                else if (ph < h)
                    p = pr;
		//查询元素的hash与当前树节点hash相同情况
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
		//上面的三步都是正常的在二叉查找树中寻找对象的方法
		//如果hash相等,但是内容却不相等
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
		//如果可以根据compareTo进行比较的话就根据compareTo进行比较
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
		//根据compareTo的结果在右孩子上继续查询
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
		//根据compareTo的结果在左孩子上继续查询
                else
                    p = pl;
            } while (p != null);
            return null;
}

get方法,首先通过hash()函数得到对应数组下标,然后依次判断。

  1. 判断第一个元素与key是否匹配,如果匹配就返回参数值;
  2. 判断链表是否红黑树,如果是红黑树,就进入红黑树方法获取参数值;
  3. 如果不是红黑树结构,直接循环判断,直到获取参数为止;

remove()方法

remove(Object key)的作用是删除key值对应的Node,该方法的具体逻辑是在removeNode(hash(key), key, null, false, true)里实现的。

深入理解HashMap源码_第10张图片

jdk1.8的删除逻辑实现比较复杂,相比jdk1.7而言,多了红黑树节点删除和调整:

  1. 默认判断链表第一个元素是否是要删除的元素;
  2. 如果第一个不是,就继续判断当前冲突链表是否是红黑树,如果是,就进入红黑树里面去找;
  3. 如果当前冲突链表不是红黑树,就直接在链表中循环判断,直到找到为止;
  4. 将找到的节点,删除掉,如果是红黑树结构,会进行颜色转换、左旋、右旋调整,直到满足红黑树特性为止。

总结

  1. HashMap是一种散列表,采用(数组 + 链表 + 红黑树)的存储结构;

  2. HashMap的默认初始容量为16(1<<4),默认装载因子为0.75f,容量总是2的n次方;

  3. HashMap扩容时每次容量变为原来的两倍;

  4. 当桶的数量小于64时不会进行树化,只会扩容;

  5. 当桶的数量大于64且单个桶中元素的数量大于8时,进行树化;

  6. 当单个桶中元素数量小于6时,进行反树化;

  7. HashMap是非线程安全的容器;

  8. HashMap查找添加元素的时间复杂度都为O(1);

你可能感兴趣的:(java,后端)