JDK源码学习——集合

// 获取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;

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;

}

get获取元素 使用HashMap有一个明显的优点，就是他的存取时间开销基本维持在O(1).

public V get(Object key) {

Node<K,V> e;

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

}

// 同一个key的hash值是相同的，通过hash就可以求出数组的下标，便可以在O(1)的时间内获取元素。

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

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

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

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

Kafka进阶篇知识点

Kafka高级篇知识点

44个Kafka知识点（基础+进阶+高级）解析如下

由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
[外链图片转存中…(img-CbCBdA5R-1712036522727)]

Kafka高级篇知识点

[外链图片转存中…(img-1lftq7ph-1712036522727)]

44个Kafka知识点（基础+进阶+高级）解析如下

[外链图片转存中…(img-pJoUCZne-1712036522728)]

由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！