【源码解析】HashMap扩容机制

//赋值

hashMap.put(“id”,1);

hashMap.put(“name”,“张三”);

//取值

// Integer id = (Integer) hashMap.get(“id”);

// String name = (String) hashMap.get(“name”);

//获取所有的key值

Set keys=hashMap.keySet();//将map的key转换成set集合

Iterator keyInterator1=keys.iterator();//将keys转换成迭代器

System.out.println(“map的所有key值===============”);

while (keyInterator1.hasNext()){

System.out.println(keyInterator1.next() );

}

System.out.println(“map的所有value值===============”);

Collection values=hashMap.values();

Iterator keyInterator2=values.iterator();

while (keyInterator2.hasNext()){

System.out.println(keyInterator2.next());

}

请看结果：

是不是与上面的赋值对应上了

下面来介绍一下HashMap的性能以及安全问题

刚刚说了HashMap的存储是基于hash算法实现的，那他具体是如何实现的呢？当程序执行HashMap的put方法时，将调用String的 hashCode() 方法得到其 hashCode 值，在这里说明一下HashCode的因子是31，最后会根据计算出来的HashCode存放Map的元素.

扩容机制

我们先来看一下HashMap的初始化，HashMap提供了4中构造函数：

//无参构造

Map<String,Object> map1 = new HashMap<String, Object>();

//有参构造 传入初始容器大小

Map<String,Object> map2 = new HashMap<String, Object>(100);

//有参构造 传入初始容器以及负载因子

Map<String,Object> map3 = new HashMap<String, Object>(100,0.8f);

//有参构造 讲一个map赋值给一个新的map

Map<String,Object> map4 = new HashMap<String, Object>(map1);

我们现在分别来看一下这几个构造函数的源码：

1.new HashMap()

/**

• Constructs an empty HashMap with the default initial capacity

• (16) and the default load factor (0.75).

*/

public HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

}

此构造只做了一件事，那就是给负载因子赋初始值：0.75

2.new HashMap<String, Object>(100);

initialCapacity：初始化的容器大小 DEFAULT_LOAD_FACTOR：初始化的负载因子大小：0.75 threshold：容器的初始化大小 但是需要注意一点我们给的初始化容器大小：100并不是最终的大小，请看下面代码：

static final int tableSizeFor(int cap) {

int n = cap - 1;

n |= n >>> 1;

n |= n >>> 2;

n |= n >>> 4;

n |= n >>> 8;

n |= n >>> 16;

return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

}

容器大小都是以2的幂形式，所以并不是我们实例化指定的，它是通过你给定的大小计算出最终的大小。

第三种和第二种构造一样，唯一区别就是第三种可以手动指定负载因子，而第二种只能使用默认的负载因子，第四种事拷贝map到新的map中。

新增方法（put）

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) {

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

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

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

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

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

else {

Node<K,V> e; K k;

if (p.hash == hash &&

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

e = p;

else if (p instanceof TreeNode)

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

else {

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

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

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

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash);

break;

}

if (e.hash == hash &&

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

break;

p = e;

}

}

if (e != null) { // existing mapping for key

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

afterNodeAccess(e);

return oldValue;

}

}

++modCount;

if (++size > threshold)

resize();

afterNodeInsertion(evict);

return null;

}

当第一次调用put()时，会进行一次resize()，resize主要作用：

1.扩容。

2.分配容器大小。

3.分配扩容的阈值。

4.如果发生扩容，数据拷贝。

源码如下：

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

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

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

int oldThr = threshold;

int newCap, newThr = 0;

if (oldCap > 0) {

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

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

oldCap >= DEFAULT_INITIAL_CAPACITY)

newThr = oldThr << 1; // double threshold

}

else if (oldThr > 0) // initial capacity was placed in threshold

newCap = oldThr;

else { // zero initial threshold signifies using defaults

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;

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

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

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

Node<K,V> next;

do {

next = e.next;

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

if (loTail == null)

loHead = e;

else

loTail.next = e;

loTail = e;

}

else {

if (hiTail == null)

hiHead = e;

else

最后

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

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

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

[外链图片转存中…(img-nEKgXIpo-1715163654220)]

[外链图片转存中…(img-6B3Bceh7-1715163654221)]

[外链图片转存中…(img-Ggh2uEss-1715163654221)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

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