HashMap Jdk8的实现原理

一、概述

       学习java三年,回首再读JDK源码,真是一种不错的体验。之前一直不怎么关注jdk源码,不关注数据结构,以为能实现各种功能就可以了。不得不自我批评这是一种错误的学习方式。

       该进入正题了,本部主要针对JDK8源码。

二、HashMap结构图

  1、JDK7及之前

        

  2、JKD8及之后

       

        由上面结构图可知,HashMap由数组和链表共同构成,JDK8对HashMap做了优化,采用了红黑树的数据结构来做优化,使得HashMap存取速度更快。

三、HashMap实例化过程

  1、几个重要的参数

HashMap几个重要属性
属性名 属性说明 JDK7 JDK8
loadFactor 加载因子,初始值=0.75,与扩容有关
threshold 临界值,与HashMap扩容相关
modCount map中数据改变次数的统计
DEFAULT_INITIAL_CAPACITY 默认的初始容量 ,=1<<4=16
MAXIMUM_CAPACITY 最大容量,=1<<30
DEFAULT_LOAD_FACTOR 默认加载因子,=0.75
TREEIFY_THRESHOLD 使用TreeNode的临界值,默认=8 ×
UNTREEIFY_THRESHOLD 与split方法有关 ×
MIN_TREEIFY_CAPACITY 最小TreeNode的容量为64 ×

  2、构造函数HashMap

    JDK8

 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;
        this.threshold = tableSizeFor(initialCapacity);
    }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    JDK7

 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;
        threshold = initialCapacity;
        init();
    }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

比较发现最大的改变就是在无参构造函数时,JDK8仅仅是初始化loadFactor让其等于默认值。而JDK7是调用了一个有参的构造函数,参数使用了默认值。

Map通过构造函数new一个HashMap时,其内部存储数据的数组并没有实例化,而是在PUT方法中去做了一件判断table是否为空的事,若为空就会调用resize()方法,resize()第一次调用就会实例化一个长度为DEFAULT_INITIAL_CAPACITY的Node[]。

四、HashMap存取put/get

  1、put(K key,V value)

        先来看一张流程图:

     

该流程图阐述了putVal()方法的整个执行过程。现在我们来看putVal()的源码

//对外开发使用
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
//存值的真正执行者
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    
    //定义一个数组,一个链表,n永远存放数组长度,i用于存放key的hash计算后的值,即key在数组中的索引        
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    
    //判断table是否为空或数组长度为0,如果为空则通过resize()实例化一个数组并让tab作为其引用,并且让n等于实例化tab后的长度        
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    
    //根据key经过hash()方法得到的hash值与数组最大索引做与运算得到当前key所在的索引值,并且将当前索引上的Node赋予给p并判断是否该Node是否存在
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);//若tab[i]不存在,则直接将key-value插入该位置上。
    
        //该位置存在数据的情况  
    else {
        Node<K,V> e; K k; //重新定义一个Node,和一个k
        
	    // 该位置上数据Key计算后的hash等于要存放的Key计算后的hash并且该位置上的Key等于要存放的Key     
        if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
            e = p;	//true,将该位置的Node赋予给e
	else if (p instanceof TreeNode)  //判断当前桶类型是否是TreeNode
	    //ture,进行红黑树插值法,写入数据
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); 	
        else {	
	    //false, 遍历当前位置链表
            for (int binCount = 0; ; ++binCount) {
                //查找当前位置链表上的表尾,表尾的next节点必然为null,找到表尾将数据赋给下一个节点
                if ((e = p.next) == null) {
                     p.next = newNode(hash, key, value, null);	//是,直接将数据写到下个节点
                    // 如果此时已经到第八个了,还没找个表尾,那么从第八个开始就要进行红黑树操作
		    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);	//红黑树插值具体操作
                        break;
                }
                //如果当前位置的key与要存放的key的相同,直接跳出,不做任何操作   
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //将下一个给到p进行逐个查找节点为空的Node
		p = e;
            }
        }
        //如果e不为空,即找到了一个去存储Key-value的Node 
	if (e != null) { // existing mapping for key
            V oldValue = e.value;    
	    if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //当最后一次调整之后Size大于了临界值,需要调整数组的容量
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

 2、取值,请看源码解析:

//对外公开方法
public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

//实际逻辑控制方法
final Node<K,V> getNode(int hash, Object key) {
	//定义相关变量
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
	//保证Map中的数组不为空,并且存储的有值,并且查找的key对应的索引位置上有值
    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
        // always check first node 第一次就找到了对应的值
	if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
	//判断下一个节点是否存在
	if ((e = first.next) != null) {
            //true,检测是否是TreeNode
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key); //通过TreeNode的get方法获取值
            //否,遍历链表
	    do {
		//判断下一个节点是否是要查找的对象
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            }while ((e = e.next) != null);
        }
    }//未找到,返回null
    return null;
 }

五、HashMap扩容机制resize()

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;	//未扩容时数组的容量
    int oldThr = threshold;
    int newCap, newThr = 0;//定义新的容量和临界值
    //当前Map容量大于零,非第一次put值
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {	//超过最大容量:2^30
			//临界值等于Integer类型的最大值 0x7fffffff=2^31-1
            threshold = Integer.MAX_VALUE;	
            return oldTab;
        }
		//当前容量在默认值和最大值的一半之间
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1;	//新临界值为当前临界值的两倍
    }
	//当前容量为0,但是当前临界值不为0,让新的容量等于当前临界值
    else if (oldThr > 0) 
        newCap = oldThr;
    //当前容量和临界值都为0,让新的容量为默认值,临界值=初始容量*默认加载因子
	else {
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
	//如果新的临界值为0
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
	//临界值赋值
    threshold = newThr;
    //扩容table
    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;//此时newCap = oldCap*2
                else if (e instanceof TreeNode) //节点为红黑树,进行切割操作
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { //链表的下一个节点还有值,但节点位置又没有超过8
                    //lo就是扩容后仍然在原地的元素链表
					//hi就是扩容后下标为  原位置+原容量  的元素链表,从而不需要重新计算hash。
					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 == 0 判断元素位置是否还在原位置
                        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);
					//循环链表结束,通过判断loTail是否为空来拷贝整个链表到扩容后table
                    if (loTail != null) {
                       loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

六、几个重点解析

1、HashMap中各个元素位置的确定

String类型和Integer类型的hashCode值,Map中hash方法

//String类型 HashCode
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

//Integer类型的 HashCode ,就是value本身
public static int hashCode(int value) {
    return value;
}

//HashMap中的hash(), 小于2^16的值的hashCode都是其本身
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

HashMap put与resize的实例图

到此,HashMap中基本的实现过程就讲完了,不对之处还请多多指教!

展开阅读全文

没有更多推荐了,返回首页