JDK源码学习——集合

HashMap底层是通过维护一个数据来保存元素。当创建HashMap实例的时候，会通过指定的数组大小以及负载因子等参数创建一个空的数组，当在容器中添加元素的时候，首先会通过hash算法求得key的hash值，再根据hash值确定元素在数组中对应的位置，最后将元素放入数组对应的位置。在添加元素的过程中会出现hash冲突问题，冲突处理的方法就是判断key值是否相同，如果相同则表明是同一个元素，替换value值。如果key值不同，则把当前元素添加到链表尾部。这里引出了一个概念，就是HashMap的数据结构其实是：hash表+单向链表。通过链表的方式把所有冲突元素放在了数组的同一个位置。但是当链表过长的时候会影响HashMap的存取效率。因此我们在实际使用HashMap的时候就需要考虑到这个问题，那么该如何控制hash冲突的出现频率呢？HashMap中有一个负载因子(loadFactor)的概念。容器中实际存储元素的size = loadFactor * 数组长度，一旦容器元素超出了这个size，HashMap就会自动扩容，并对所有元素重新执行hash操作，调整位置。好了说了这么多，下面就开始介绍源码实现。

hashMap 的数组大小必须是2 的幂，至于为什么，感兴趣的可以搜一下，这里先不说了，我想要的讲的是HashMap 的put方法，也就是为马map中添加一个元素。Map添加元素的方式是通过put，向容器中存入一个Key-Value对。下面我将详细介绍put的实现过程，这个方法非常重要，吃透了这个方法的实现原理，基本也就能搞懂HashMap是怎么一回事了。

大致上：首先会判断是否第一次添加元素，如果是第一次，就会先创建一个一定大小的数组（table）。接着通过hash与数组长度的操作，确定key对应的位置，也就是key值通过hash算法在数组中确定存储位置。如果找到的位置为空，那么就在当前数组位置，为这个key-value创建一个节点。如果对应的位置有值，则会和key值进行比较，如果key值相同，则表明是同一个元素，直接把value值替换。如果key值不相同，那么就会进行遍历整个数组，如果找到了有相同的key值，则在对应位置替换其value值。如果没有找到相同的key值，那么就在链表尾部添加中这个元素。源代码如下：

public V put(K key, V value) {

return putVal(hash(key), key, value, false, true);

}

// 获取key的hash值，这里讲hash值的高16位右移和低16位做异或操作，目的是为了减少hash冲突，使hash值能均匀分布。

static final int hash(Object key) {

int h;

return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

boolean evict) {

Node<K,V>[] tab; Node<K,V> p; int n, i;

// 如果是第一次添加元素，那么table是空的，首先创建一个指定大小的table。

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

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

// 通过对hash与数组长度的与操作，确定key对应的数组位置，然后读取该位置中的元素。

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

// 如果当前位置为空，那么就在当前数组位置，为这个key-value创建一个节点。

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

else {

// 如果当前位置已经存在元素，那么就要逐个读取这条链表的元素。

Node<K,V> e; K k;

// 如果key和hash值都等于当前头元素，那么这存放的两个元素是相同的。

if (p.hash == hash &&

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

e = p;

// 如果当前位置的链表类型是TreeNode，那么就讲当前元素以红黑树的形式存放。

else if (p instanceof TreeNode)

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

else {

for (int binCount = 0; ; ++binCount) {

// 遍历链表的所有元素，如果都未找到相同key的元素，那么说明这个元素并不在容器中存在，因此将他添加到链表尾部，并结束遍历。

if ((e = p.next) == null) {

p.next = newNode(hash, key, value, null);

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;

}

}

// 如果e != null 说明在当前容器中，存在一个相同的key值，那么就要替换key所对应的value

if (e != null) {

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

// 这是专门留给LinkedHashMap调用的回调函数，LinkedHashMap会实现这个方法。从这里可以看出，HashMap充分的考虑了他的扩展性。

afterNodeAccess(e);

return oldValue;

}

}

++modCount;

// 这里判断当前元素的数量是否超过了容量的上限，如果超过了，就要重新进行扩容，并对当前元素重新hash，所以再次扩容以后的元素位置都是会改变的。

if (++size > threshold)

resize();

// 此方法也是HashMap留给LinkedHashMap实现的回调方法。透露一下，因为LinkedHashMap在插入元素以后，都会维护他的一个双向链表

afterNodeInsertion(evict);

return null;

}

再说一句,在put元素的过程中，可能会出现当前元素的数量超过了容量上限，那么就会进行扩容，前面提到了haspmap的容量必须为2的幂，所以每次扩容都是之前的两倍，再次扩容之后会对元素重新hash,所以元素的位置会发生改变。下面附上扩容方法的源代码：

final Node<K,V>[] resize() {

Node<K,V>[] oldTab = table;

int oldCap = (oldTab == null) ? 0 : oldTab.length;

int oldThr = threshold;

int newCap, newThr = 0;

// 如果容器并不是第一次扩容的话，那么oldCap必定会大于0

if (oldCap > 0) {

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

// threshold和数组大小cap共同扩大为原来的两倍

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

oldCap >= DEFAULT_INITIAL_CAPACITY)

newThr = oldThr << 1;

}

// 第一次扩容，并且设定了threshold值。

else if (oldThr > 0)

newCap = oldThr;

else {

// 如果在创建的时候并没有设置threshold值，那就用默认值

newCap = DEFAULT_INITIAL_CAPACITY;

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

}

if (newThr == 0) {

// 第一次扩容的时候threshold = cap * loadFactor

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;

// 如果不是第一次扩容，那么hash表中必然存在数据，需要将这些数据重新hash

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;

else if (e instanceof TreeNode)

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

else { // preserve order

// 这里分两串，lo表示原先位置的所有，hi表示新的索引

Node<K,V> loHead = null, loTail = null;

Node<K,V> hiHead = null, hiTail = null;

Node<K,V> next;

do {

next = e.next;

// 因为cap都是2的幂次，假设oldCap == 10000，

// 假设e.hash= 01010 那么 e.hash & oldCap == 0。

// 老位置= e.hash & oldCap-1 = 01010 & 01111 = 01010

// newCap此时为100000，newCap-1=011111。

// 此时e.hash & newCap 任然等于01010，位置不变。

// 如果e.hash 假设为11010，那么 e.hash & oldCap != 0

// 原来的位置为 e.hash & oldCap-1 = 01010

// 新位置 e.hash & newCap-1 = 11010 & 011111 = 11010

// 此时 新位置 != 老位置 新位置=老位置+oldCap

// 因此这里分类两个索引的链表

if ((e.hash & oldCap) == 0) {

if (loTail == null)

loHead = e;

先自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以扫码领取！

最后

这份文档从构建一个键值数据库的关键架构入手，不仅带你建立起全局观，还帮你迅速抓住核心主线。除此之外，还会具体讲解数据结构、线程模型、网络框架、持久化、主从同步和切片集群等，帮你搞懂底层原理。相信这对于所有层次的Redis使用者都是一份非常完美的教程了。

整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~

你的支持，我的动力；祝各位前程似锦，offer不断！！！
4671a72faed303032d36.jpg" alt=“img” style=“zoom: 33%;” />

最后

这份文档从构建一个键值数据库的关键架构入手，不仅带你建立起全局观，还帮你迅速抓住核心主线。除此之外，还会具体讲解数据结构、线程模型、网络框架、持久化、主从同步和切片集群等，帮你搞懂底层原理。相信这对于所有层次的Redis使用者都是一份非常完美的教程了。

[外链图片转存中…(img-7VvFVDNj-1711392455654)]

整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~

你的支持，我的动力；祝各位前程似锦，offer不断！！！
需要更多Java资料的小伙伴可以帮忙点赞+关注，点击传送门，即可免费领取！