HashMap源码解析

HashMap源码解析

全文围绕JDK8 来讲解hashmap

1.HashMap的存储结构

hashMap采用的哈希表的方式存储,采用一个数组的存储不同哈希值的数据。相同哈希值的数据,会存放于同一个数组单元之中,最开始是以链表的形式去存储数据,采用尾插入的形式进行插入。当达到一个阈值( binCount >= TREEIFY_THRESHOLD - 1 )的时候,将会执行treeifyBin方法构建红黑树。

众所周知,当数据量大的时候链表遍历带来的影响会很大( 时间复杂度O(n) ),因此转换为红黑树将会大幅提升效率( 时间复杂度(logn) )

红黑树知识补充:

每个节点只有两种颜色:红色或者黑色
根节点必须是黑色
每个叶子节点(NIL)都是黑色的空节点
从根节点到叶子节点,不能出现两个连续的红色节点
从任一节点出发,到它下边的子节点的路径包含的黑色节点数目都相同

2.HashMap常量

以下是复制于源码,中文是机翻

//默认的初始化容量为16,必须是2的n次幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

// 最大容量,在两个带参数的构造函数隐式指定更高值时使用。必须是 2 的幂 <= 1<<30。
static final int MAXIMUM_CAPACITY = 1 << 30;

// 在构造函数中未指定时使用的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 使用树而不是列表的 bin 计数阈值。将元素添加到至少具有这么多节点的 bin 时,bin 会转换为树。该值必须大于 2 且至少应为 8,以与树移除中关于在收缩时转换回普通 bin 的假设相匹配。
static final int TREEIFY_THRESHOLD = 8;

// 在调整大小操作期间取消(拆分)bin 的 bin 计数阈值。应小于 TREEIFY_THRESHOLD,最多为 6 以在移除下进行收缩检测。
static final int UNTREEIFY_THRESHOLD = 6;

// 可以将 bin 树化的最小表容量。 (否则,如果 bin 中的节点过多,则表将调整大小。)应至少为 4 * TREEIFY_THRESHOLD,以避免调整大小和树化阈值之间发生冲突。
static final int MIN_TREEIFY_CAPACITY = 64;

// 表,在第一次使用时初始化,并根据需要调整大小。分配时,长度始终是 2 的幂。 (我们还在某些操作中容忍长度为零,以允许当前不需要的引导机制。)
transient Node<K,V>[] table;

// 保存缓存的 entrySet()。请注意,AbstractMap 字段用于 keySet() 和 values()。
transient Set<Map.Entry<K,V>> entrySet;

// 此映射中包含的键值映射数。数组个数
transient int size;

// 该 HashMap 被结构修改的次数该字段用于在 HashMap 的 Collection-views 上创建迭代器快速失败。 (请参阅 ConcurrentModificationException)。
transient int modCount;

//数组扩容阈值
int threshold;

//加载因子
final float loadFactor;					

// 基本哈希 bin 节点,用于大多数条目。 (请参阅下面的 TreeNode 子类,以及 LinkedHashMap 中的 Entry 子类。)
static class Node<K,V> implements Map.Entry<K,V> {
	//key的hash值,put和get的时候都需要用到它来确定元素在数组中的位置
	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;
	}
}

// 树箱的条目。扩展 LinkedHashMap.Entry(进而扩展节点),因此可以用作常规节点或链接节点的扩展。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
	//当前节点的父节点
	TreeNode<K,V> parent;  
	//左孩子节点
	TreeNode<K,V> left;
	//右孩子节点
	TreeNode<K,V> right;
	//指向前一个节点
	TreeNode<K,V> prev;    // needed to unlink next upon deletion
	//当前节点是红色或者黑色的标识
	boolean red;
	TreeNode(int hash, K key, V val, Node<K,V> next) {
		super(hash, key, val, next);
	}
}

3.put()方法,插入的流程

/*
	将指定值与此映射中的指定键相关联。如果映射先前包含键的映射,则旧值将被替换。
    参数:
        key – 与指定值关联的键
        value – 要与指定键关联的值
    返回:
    	与 key 关联的先前值,如果没有 key 的映射,则为 null。 (空返回也可以表明映射先前将空与键相关联。)
*/
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

先通过计算key的哈希值,计算hashcode 的方法由各自实体各自实现,并通过位异或右移计算把hashcode充分打散,减低hash冲突的概率。

那倒是怎么通过位运算打散的呢?下面我们来做一个例子

原始hash位值:  	       1100 1100 1001 0110 1001 1010 1000 0100 
右移16的位值:  	       0000 0000 0000 0000 1100 1100 1001 0110 
异或加右移16的位值 :     1100 1100 1001 0110 0101 0110 0001 0010 

根据这个例子 我们看到,结果是对后16位进行了位异或运算。保留了高16位的特征,对低位进行异或运算,尽可能保持高16位的特征,从而降低哈希碰撞的概率。

再结合 当前数组的长度算出当前key在数组中是第几个元素

 tab[i = (n - 1) & hash]   // n是数组长度,hashmap的初始长度是16

进入这里有两个判断,定位到数组下标的元素是否为空,若为空则新建一个节点,该节点后续将会以一个链表的连接起后面的节点。

tab[i] = newNode(hash, key, value, null);    // 详细结构参考上面的Node

如果已经存在元素,则进入else 块

HashMap.Node<K,V> e; K k;
// 当前位置元素的hash值等于传过来的hash,并且他们的key值也相等,则把p赋值给e  进入下一步操作。
// 这里判断第一个是因为如果是链表结构的话,头结点是不会再判断的了,只会判断后面的结点
if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k))))
    e = p;
// 如果p的结构是一个红黑树的结构
else if (p instanceof HashMap.TreeNode)
    e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//  进入到这里就表明了,key的hash相同,key值不一样,不是树结构,就代表这里是链表的结构,采用尾插的方式,把节点插入到链表最后面
    for (int binCount = 0; ; ++binCount) {
        // 一直遍历链表,直到去到链表最后一个元素中,p.next==null 代表该节点是链表最后一个节点
        if ((e = p.next) == null) {
            p.next = newNode(hash, key, value, null);
            // 这个是判断当前链表的数量是否大于等于8个,要是成立,则将链表树化。因为链表一长,插入和查询效率将会大大降低
            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                treeifyBin(tab, hash);
            break;
        }
        // 跟第一个判断一样,判断是否同一个key,若同一个key,则进入下一步操作,等等进行覆盖的操作
        if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
            break;
        // 这个循环里的第一个if 是指向下一个结点的,并赋值给了e。(这jdk的写法真恶心)
        p = e;
    }
}
// 进入这里代表key本来就存在了,产生了冲突,结点位置不变,替换旧值
if (e != null) { // existing mapping for key
    V oldValue = e.value;
    // onlyIfAbsent 为true 不改变值, 但如果旧值是null的话,依然会替换。
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
    // 这里在hashMap是一个空实现,在linkedHashMap才会具体实现。是根据访问先后顺序对元素进行排序
    // 这是在node被访问后需要做的操作。
    afterNodeAccess(e);
    return oldValue;
} 

具体对链表的插入已经讲解的差不多了。我们还漏了一部分,就是当他超过预设阈值,采用红黑树的插入方式,这里就大致列举一下,因为重点还是hashmap。

final HashMap.TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    HashMap.TreeNode<K,V> root = (parent != null) ? root() : this;
    
    for (HashMap.TreeNode<K,V> p = root;;) {
        int dir, ph; K pk;
        if ((ph = p.hash) > h)
            dir = -1;
        else if (ph < h)
            dir = 1;
        // key值一样的节点
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        // 
        else if ((kc == null &&
                (kc = comparableClassFor(k)) == null) ||
                (dir = compareComparables(kc, k, pk)) == 0) {
            if (!searched) {
                HashMap.TreeNode<K,V> q, ch;
                searched = true;
                if (((ch = p.left) != null &&
                        (q = ch.find(h, k, kc)) != null) ||
                        ((ch = p.right) != null &&
                                (q = ch.find(h, k, kc)) != null))
                    return q;
            }
            dir = tieBreakOrder(k, pk);
        }

		// 判断是左子树还是右子树 并判断是否为空,不为空继续往下一个结点走
        HashMap.TreeNode<K,V> xp = p;
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            HashMap.Node<K,V> xpn = xp.next;
            HashMap.TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            xp.next = x;
            x.parent = x.prev = xp;
            if (xpn != null)
                ((HashMap.TreeNode<K,V>)xpn).prev = x;
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;
        }
    }
}

最后在putVal的后面还有一段代码

++modCount;
// 如果size > (容量*负载因子)  重新扩容
if (++size > threshold)
     resize();  // 下面细讲
// 在HashMap中是一个空实现,具体实现在linkedHashMap中 是节点插入之后的操作
afterNodeInsertion(evict);

4.resize()方法实现的内容

当size > 负载数 则进行重新计算容量(新增,删除都会重新计算)

HashMap.Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 现有容量是否大于0 如果这个判断进入 一定是经历过一次resize的
if (oldCap > 0) {
    // 容量大于 hashMap 设置的最大容量 将用Integer 最大值作为负载值
    if (oldCap >= MAXIMUM_CAPACITY) {   // 1 << 30
        threshold = Integer.MAX_VALUE;
        return oldTab;
    }
    // 扩容:新容量=旧容量的两倍,阈值也是直接2倍
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
            oldCap >= DEFAULT_INITIAL_CAPACITY)
        newThr = oldThr << 1; // double threshold
}
// 现有容量等于0,但阈值数大于0。这种情况一般出现在有参构造的情况下,其实也是相当于一种初始化
// public HashMap(int initialCapacity, float loadFactor) 
// 在这种情况下 会出现容量为0,oldThr 大于0的情况  并配合下面 if(newThr == 0)使用
else if (oldThr > 0) // initial capacity was placed in threshold
    newCap = oldThr;
else {               // 都是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;
// 我们可以发现,在构造函数时,并没有创建数组,在第一次调用put方法,导致resize的时候,才会把数组创建出来。这是为了延迟加载,提高效率。
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;

上面代码讲解的是对HashMap容量处理的代码,下面就讲到因为扩容导致的重新hash的代码,有可能产生红黑树拆成多个,和退化成红黑树的情况。

if (oldTab != null) {
    for (int j = 0; j < oldCap; ++j) {
        HashMap.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 HashMap.TreeNode)
                ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
            // 到这里说明,这是一个长度大于 1 的普通链表,则需要计算并判断当前位置的链表是否需要挪到新的位置
            else { // preserve order
                // 旧位置头尾节点
                HashMap.Node<K,V> loHead = null, loTail = null;
                // 新位置头尾节点
                HashMap.Node<K,V> hiHead = null, hiTail = null;
                HashMap.Node<K,V> next;
                // 遍历链表,直至找到尾部
                do {
                    next = e.next;
                    //如果当前元素的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);
                if (loTail != null) {
                    loTail.next = null;
                    newTab[j] = loHead;
                }
                if (hiTail != null) {
                    hiTail.next = null;
                    newTab[j + oldCap] = hiHead;
                }
            }
        }
    }
}
return newTab;    

5.get()详细解析

我们理解完put之后,理解get就事半功倍了。

public V get(Object key) {
   Node<K,V> e;
   return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final HashMap.Node<K,V> getNode(int hash, Object key) {
    HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n; K k;
    // 跟put对应,get时计算所在数字的下标,计算是一样的
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        // 总是检查头结点,哈希值一样,值一样就直接返回第一个
        if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 第一个找不到,并且改值下面有值
        if ((e = first.next) != null) {
            // 如果是树结构则使用红黑树的找节点的方法
            if (first instanceof HashMap.TreeNode)
                return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
            // 不是的话遍历链表直至找到最后一个
            do {
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

后续有空继续补充红黑树相关知识和其他方法的解析,以及LinkedHashMap,HashSet

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值