Java基础-HashMap1.8前后

最新推荐文章于 2022-08-12 17:50:07 发布

Wan9_Xion9

最新推荐文章于 2022-08-12 17:50:07 发布

阅读量546

点赞数 2

分类专栏： Java基础

本文链接：https://blog.csdn.net/wxssbsb/article/details/116206482

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、HashMap1.8之前

HashMap1.8之前的数据结构是采用数组+链表组成。

我们的重点可以放到1.8以后对HashMap进行的一系列优化。

2、HashMap1.8之后

HashMap1.8之后的数据结构是采用数组+链表+红黑树组成

1.8主要优化了哪些低地方？

数组+链表改成了数组+链表或红黑树；
链表的插入方式从头插法改为了尾插法，简单说就是插入时，如果数组位置上已经有元素，1.7将新元素放到数组中，原始节点作为新节点的后继节点，1.8遍历链表，将元素放置到链表的最后；
扩容的时候1.7需要对原数组中的元素进行重新hash定位在新数组的位置，1.8采用更简单的判断逻辑，位置不变或索引+旧容量大小；
在插入时，1.7先判断是否需要扩容，在插入；1.8先进行插入，插入完成再判断是否需要扩容；

为什么1.8后要升级HashMap的数据结构呢？

这主要是为了提升性能。因为在hash冲突严重的时（链表过长）的查找性能，使用链表的查找性能是O(n)，而使用红黑树是O(logn)

什么时候使用链表？什么时候使用红黑树？

对于插入的时候，默认情况下是使用链表节点。

当同一个索引位置在新增后达到9个（阈值8）：

如果此时链表长度大于64，就会触发链表节点转换为红黑树节点（treeifyBin）；

如果数组长度小于64，则不会触发链表转换红黑树，而是会进行扩容，因为此时的数据量还比较小。

对于删除，当同一个索引位置的节点在移除后达到6个，并且该索引位置的节点为红黑树节点，会出发红黑树节点转链表节点

为什么链表转红黑树的阈值是8？

在进行方案设计时，需要考虑两个很重要的因素：时间和空间。阈值8是在时间和空间上权衡后的结,。红黑树节点占用空间大小为链表的节点的2倍，在节点太少时，红黑树的查找性能并不明显，付出2倍空间的代价作者觉得不值得。另外通过计算，链表中个数为8时的概率是十分低的。因此8是个合理的数字。

为什么转回链表用6而不是复用8？

如果设置8个转为红黑树，少于8个转为链表，当节点个数在8个徘徊时，就会频繁进行红黑树和链表的转换，造成性能的损耗。

HashMap有哪些主要的属性？分别用于做什么？

用于存储节点table数组。

size：HashMap已经存储的节点个数

threshold：扩容阈值，当HashMap的个数达到该值，会出发扩容机制

loadFactor：负载因子（默认是0.75），扩容阈值 = 容量 * 负载因子

threshold除了用于存储扩容阈值还有其他作用吗？

在新建HashMap对象时，threshold还会被用来存初始化时的容量。HashMap直到我们第一次插入节点时，才会对table进行初始化，避免不必要的空间浪费。

HashMap默认的初始容量是多少？HashMap的容量有什么限制吗？

默认容量是16。HashMap的容量必须是2的n此房，HashMap会根据我们传入的容量计算一个大于等于的最小的2的n次方，例如传9，容量为16

HashMap的初始化容量是如何计算的？

先上源码
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;
}
这段代码的 |= 等于 n = n | n>>>1

>>>为无符号右移，将a>>>b指的是a向右移动b指定的位数，右移后左边空出来的位用零来填充，移除右边的位被丢弃

假设 n 的值为 0010 0001，则该计算如下图：

我们可以通过这个公式，将最高位的1，之后全部设置为1。得到一个低位全是1的值，然后返回的值+1，会得到1个比n大的2次方的数

再回头看最开始cap-1，其实就是为了避免传递进来的数本来就是2的n次方的情况。

为什么HashMap的容量必须是2的N次方？

计算索引位置的公式为：(n-1)&hash，当n为2的N次方，n-1位低位全是1的值，此时任何值和n-1进行&运算的结果为该值的低N位，达到了和取模相同的效果，实现了均匀分布。

HashMap的默认初始化容量是16，为什么是16？

16主要是2的N次方，是一个比较合理的大小。但是在新建HashMap时，最好是根据自己使用情况设置初始值，这才是最合理的方案。

为什么负载因子是0.75？

这是在空间和时间上权衡的结果。如果值较高，是1，此时会减少空间开销，但是hash冲突的概率会增大，增加查找成本。如果是0.5，会减少hash冲突，但是有一半的空间被浪费，所以选择0.75。

HashMap插入的流程是怎样的？

先上源码
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;
	//根据(n - 1) & hash计算出数组的key值，然后判断key值的节点是否有值
	if ((p = tab[i = (n - 1) & hash]) == null)
		//没有值直接创建节点
		tab[i] = newNode(hash, key, value, null);
	else {//进入else说明发生了hash冲突，key有值
		Node<K,V> e; K k;
		// 如果在首结点与我们待插入的元素有相同的hash和key值，则先记录
		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);
					//判断链表数量是否达到阈值8
					if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
						//链表数量达到阈值，准备去转换为红黑树或者扩容
						treeifyBin(tab, hash);
					break;
				}
				//如果找到了于key相同的hash，则停止遍历
				if (e.hash == hash &&
					((k = e.key) == key || (key != null && key.equals(k))))
					break;
				p = e;
			}
		}
		//e中记录了相同元素的节点
		if (e != null) { // existing mapping for key
			V oldValue = e.value;
			if (!onlyIfAbsent || oldValue == null)
				e.value = value;
			afterNodeAccess(e);
			return oldValue;
		}
	}
	++modCount;
	//判断当前存在数组中的节点+1后是否超过了阈值，超过了进行扩容
	if (++size > threshold)
		//进行扩容
		resize();
	afterNodeInsertion(evict);
	return null;
}
//准备去转换为红黑树或者扩容的方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
	int n, index; Node<K,V> e;
	//判断数组长度是否达到了阈值64
	if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
		//如果阈值没有达到了64，就会进行扩容，不会转换为红黑树
		resize();
	//转换为红黑树的过程
	else if ((e = tab[index = (n - 1) & hash]) != null) {
		TreeNode<K,V> hd = null, tl = null;
		do {
			TreeNode<K,V> p = replacementTreeNode(e, null);
			if (tl == null)
				hd = p;
			else {
				p.prev = tl;
				tl.next = p;
			}
			tl = p;
		} while ((e = e.next) != null);
		if ((tab[index] = hd) != null)
			hd.treeify(tab);
	}
}
大致的流程可以分为以下几步：

判断数组是否为空，为空进行初始化；
不为空，计算k的hash值，通过(n-1)&hash计算当前存放在数组中的下标idnex；
查看table[index]是否存在数据，没有数据就构造一个Node节点存放在table[index]中；
存在数据，说明发生了hash冲突（存在两个节点key的hash值一样），继续判断key是否相等，相等，用心得value替换元数据
如果不相等，判断当前节点是否是树类型，如果是树类型，创造树节点插入红黑树中；（如果当前节点是树节点说明当前已经是红黑树了）
如果不是树型节点，创建普通的Node加入链表中；判断链表长度是否大于8并且数组长度大于64，大于的话将链表转换为红黑树；否则只会进行扩容，不会转换为红黑树；
插入完成之后判断当前节点数是否大于阈值，如果大于开始扩容为原数组的2倍

除了HashMap，还用过哪些Map，如何选择？