1.HashMap集合介绍
- HashMap从1.2开始。线程不安全(实现不同步),但是效率高。JDK1.8之前底层是数组+链表组成。数组作为主体,当有Hash冲突 (两个对象调用的 hashCode 方法计算的哈希值一致导致计算的索引值相同) 的时候才使用链表。HashMap的Key和Value都能为空,但只能有一个空key。
- jdk1.8 以后在解决哈希冲突时有了较大的变化,当链表长度大于阈值(或者红黑树的边界值,默认为 8 )并且当前数组的长度大于64时,此时此索引位置上的所有数据改为使用红黑树存储。
- 补充:将链表转换成红黑树前会判断,即便阈值大于8,但是数组长度小于64,此时并不会将链表变为红黑树,而是选择逬行数组扩容。
- 小结:
HashMap 特点:
1、存储无序的。
2、键和值位置都可以是 null,但是键位置只能存在一个 null。
3、键位置是唯一的,是底层的数据结构控制的。
4、jdk1.8 前数据结构是链表+数组,jdk1.8 之后是链表+数组+红黑树。
5、链表长度> 8 并且数组长度大于 64,才将链表转换为红黑树,变为红黑树的目的是为了高效的查询。
2.HashMap底层数据结构
jdk1.8 前数据结构是链表+数组,jdk1.8 之后是链表+数组+红黑树
代码:
HashMap<String, Integer> mx = new HashMap<>();
map.put("柳岩", 18);
map.put("杨幂", 28);
map.put("刘德华", 40);
map.put("柳岩", 20);
System.out.print(mx);
结果:
{杨幂=28, 柳岩=20, 刘德华=40}
若key值相同,则后面添加的会覆盖前面的Value。
分析:
HashMap<String, Integer> mx = new HashMap<>();
-
当创建 HashMap 集合对象的时候,在 jdk1.8 之前,在HashMap的构造方法中创建一个长度是16的 Entry[] table 用来存储键值对数据的。在== jdk1.8 以后== 不是在 HashMap 的构造方法底层创建数组了,是在第一次调用 put 方法时创建的数组 Node[] table 用来存储键值对数据。
-
假设向哈希表中存储 <柳岩,18> 数据,根据柳岩调用 String 类中重写之后的 hashCode() 方法计算出值,然后结合数组长度采用某种算法计算出向 Node 数组中存储数据的空间的索引值。如果计算出的索引空间没有数据,则直接将<柳岩,18>存储到数组中。(举例:计算出的索引是 3 )
HashMap底层是如何计算出索引值的?还有什么方法可以计算索引值?
底层采用的是key的HashCode的值结合数组长度进行无符号的右移(>>>)、按位异或(^)、按位与(&)。【效率比取余高,因为位运算很快,而取余在计算机底层是除与减法,很慢】。
还可以采用 平方取中法、取余数、伪随机法。
-
向哈希表中存储数据 <刘德华,40>,假设算出的 hashCode() 方法结合数祖长度计算出的索引值也是3,那么此时数组空间不是 null,此时底层会比较柳岩和刘德华的key值是否一致,如果不一致,则在空间上划出一个结点来存储键值对数据对 <刘德华,40>,这种方式称为拉链法。key的hash值一致的话就覆盖。
-
假设向哈希表中存储数据 <柳岩,20>,那么首先根据柳岩调用 hashCode() 方法结合数组长度计算出索引肯定是 3,此时比较后存储的数据柳岩和已经存在的数据的 hash 值是否相等,如果 hash 值相等,此时发生哈希碰撞。那么底层会调用柳岩所属类 String 中的 equals() 方法比较两个内容是否相等。
相等:将后添加的数据的 value 覆盖之前的 value。
不相等:继续向下和其他的数据的 key 进行比较,如果都不相等:则划出一个结点存储数据,如果结点长度即链表长度大于阈值 8 并且数组长度大于 64 则将链表变为红黑树。
在已有的链表中插入Entry,在jdk1.8之前是插入链表头部的,在jdk1.8中是插入尾部的。
-
在不断的添加数据的过程中,会涉及到扩容问题,当超出阈值(且要存放的位置非空)时,扩容。默认的扩容方式:扩容为原来容量的 2 倍,并将原有的数据复制过来。第一次put后的初始长度为16。
-
综上描述,当位于一个表中的元素较多,即 hash 值相等但是内容不相等的元素较多时,通过 key 值依次查找的效率较低。而 jdk1.8 中,哈希表存储采用数组+链表+红黑树实现,当链表长度(阈值)超过8且当前数组的长度大于64时,将链表转换为红黑树,这样大大减少了查找时间。
-
简单的来说,哈希表是由数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的。如下图所示:
-
jdk1.8 中引入红黑树的进一步原因:
jdk1.8以前 HashMap 的实现是数组+链表,即使哈希函数取得再好,也很难达到元素百分百均匀分布。当HashMap中有大量的元素都存放到同一个桶中时,这个桶下有一条长长的链表,这个时候 HashMap 就相当于一个单链表,假如单链表有n个元素,遍历的时间复杂度就是O(n),完全失去了它的优势。
针对这种情况,jdk1.8中引入了红黑树(查找时间复杂度为O(logn))来优化这个问题。当链表长度很小的时候,即使遍历,速度也非常快,但是当链表长度不断变长,肯定会对查询性能有一定的影响,所以才需要转成树。
总结:
说明:
size 表示 HashMap 中键值对的实时数量,注意这个不等于数组的长度。
threshold(临界值)= capacity(容量)* loadFactor(负载因子)。这个值是当前已占用数组长度的最大值。size超过这个值就重新 resize(扩容),扩容后的 HashMap 容量是之前容量的两倍。
面试题
HashMap 中 hash 函数是怎么实现的?还有哪些hash函数的实现方式?
答:对于 key 的 hashCode 做 hash 操作,无符号右移 16 位然后做异或运算。还有平方取中法,伪随机数法和取余数法。这三种效率都比较低。而无符号右移 16 位异或运算效率是最高的。
当两个对象的 hashCode 相等时会怎么样?
答:会产生哈希碰撞。若 key 值内容相同则替换旧的 value,不然连接到链表后面,链表长度超过阈值 8 就转换为红黑树存储。
什么是哈希碰撞,如何解决哈希碰撞?
答:只要两个元素的 key 计算的哈希码值相同就会发生哈希碰撞。jdk8 之前使用链表解决哈希碰撞。jdk8之后使用链表 + 红黑树解决哈希碰撞。
如果两个键的 hashCode 相同,如何存储键值对?
答:通过 equals 比较内容是否相同。相同:则新的 value 覆盖之前的 value。不相同:则将新的键值对添加到哈希表中。
3.HashMap继承关系说明:
Cloneable 空接口,表示可以克隆。创建并返回 HashMap 对象的一个副本。
Serializable 序列化接口。属于标记性接口。HashMap 对象可以被序列化和反序列化。
AbstractMap 父类提供了 Map 实现接口。以最大限度地减少实现此接口所需的工作。
补充:
通过上述继承关系我们发现一个很奇怪的现象,就是 HashMap 已经继承了AbstractMap 而 AbstractMap 类实现了Map 接口,那为什么 HashMap 还要在实现 Map 接口呢?同样在 ArrayList 中 LinkedLis 中都是这种结构。
据 Java 集合框架的创始人 Josh Bloch 描述,这样的写法是一个失误。在 Java 集合框架中,类似这样的写法很多,最幵始写 Java 集合框架的时候,他认为这样写,在某些地方可能是有价值的,直到他意识到错了。显然的,jdk 的维护者,后来不认为这个小小的失误值得去修改,所以就这样保留下来了。
4.HashMap 集合类的成员
4.1 成员变量
- 序列化版本号
private static final long serialVersionUID = 362498820763181265L;
- 集合的初始化容量
必须是2的n次幂
// 默认的初始容量是16 1 << 4 相当于 1*2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
问题:为什么必须是 2 的 n 次幂?如果输入值不是 2 的幂比如 10 会怎么样?
根据上述讲解我们已经知道,当向 HashMap 中添加一个元素的时候,需要根据 key 的 hash 值,去确定其在数组中的具体位置。HashMap 为了存取高效,减少碰撞,就是要尽量把数据分配均匀,每个链表长度大致相同,这个实现的关键就在把数据存到哪个链表中的算法。
这个算法实际就是取模,hash % length,计算机中直接求余效率不如位移运算。所以源码中做了优化,使用 hash & (length - 1),而实际上 hash % length 等于 hash & ( length - 1) 的前提是 length 是 2 的 n 次幂。
比如长度为16,是10000
length-1=1111
然后用hash和1111进行按位与(&)操作
17==》10001 与1111与就是 1;
得到的就是对16取模
说明:
当在实例化 HashMap 实例时,如果给定了 initialCapacity,由于 HashMap 的 capacity 必须都是 2 的幂,因此这个方法用于找到大于等于 initialCapacity 的最小的 2 的幂。(给了10,定为16)
- 默认的负载因子(默认值 0.75)
static final float DEFAULT_LOAD_FACTOR = 0.75f;
- 集合最大容量
static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次幂
- 当链表的值超过8则会转为红黑树
// 当桶(bucket)上的结点数大于这个值时会转为红黑树
static final int TREEIFY_THRESHOLD = 8;
- 当链表的值小于 6 则会从红黑树转回链表
// 当桶(bucket)上的结点数小于这个值,树转为链表
static final int UNTREEIFY_THRESHOLD = 6;
- table
// 存储元素的数组
transient Node<K,V>[] table;
在 jdk1.8 中我们了解到 HashMap 是由数组加链表加红黑树来组成的结构,其中 table 就是 HashMap 中的数组,jdk8 之前数组类型是 Entry<K,V> 类型。从 jdk1.8 之后是 Node<K,V> 类型。只是换了个名字,都实现了一样的接口:Map.Entry<K,V>。负责存储键值对数据的。
- entrySet
存放缓存
// 存放具体元素的集合
transient Set<Map.Entry<K,V>> entrySet;
- size
HashMap 中存放元素的个数(重点)
// 存放元素的个数,注意这个不等于数组的长度
transient int size;
size 为 HashMap 中 K-V 的实时数量,不是数组 table 的长度。
- modCount
用来记录 HashMap 的修改次数
// 每次扩容和更改 map 结构的计数器
transient int modCount;
- threshold
// 临界值 当实际大小(容量*负载因子)超过临界值时,会进行扩容
int threshold;
- loadFactor
// 负载因子
final float loadFactor;
说明:
- loadFactor 是用来衡量 HashMap 满的程度,表示HashMap的疏密程度,影响 hash 操作到同一个数组位置的概率,计算 HashMap 的实时负载因子的方法为:size/capacity,而不是占用桶的数量去除以 capacity。capacity 是桶的数量,也就是 table 的长度 length。
- loadFactor 太大导致查找元素效率低,太小导致数组的利用率低,存放的数据会很分散。loadFactor 的默认值为 0.75f 是官方给出的一个比较好的临界值。
- 当 HashMap 里面容纳的元素已经达到 HashMap 数组长度的 75% 时,表示 HashMap 太挤了,需要扩容,而扩容这个过程涉及到 rehash、复制数据等操作,非常消耗性能。所以开发中尽量减少扩容的次数,可以通过创建 HashMap 集合对象时指定初始容量来尽量避免。
- 在 HashMap 的构造器中可以定制 loadFactor。
// 构造方法,构造一个带指定初始容量和负载因子的空HashMap
HashMap(int initialCapacity, float loadFactor);
为什么负载因子设置为0.75,初始化临界值是12?
loadFactor 越趋近于1,那么 数组中存放的数据(entry)也就越多,也就越密,也就是会让链表的长度增加,loadFactor 越小,也就是趋近于0,数组中存放的数据(entry)也就越少,也就越稀疏。
如果希望链表尽可能少些,要提前扩容。有的数组空间有可能一直没有存储数据,负载因子尽可能小一些。
所以既兼顾数组利用率又考虑链表不要太多,经过大量测试 0.75 是最佳方案。
threshold 计算公式:capacity(数组长度默认16) * loadFactor(负载因子默认0.75)。
这个值是当前已占用数组长度的最大值。当 Size >= threshold 的时候,那么就要考虑对数组的 resize(扩容),也就是说,这个的意思就是衡量数组是否需要扩增的一个标准。 扩容后的 HashMap 容量是之前容量的两倍。
5.构造方法
- 无参构造
构造一个空的HashMap,默认初始容量(16)和默认负载因子(0.75)。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 将默认的负载因子0.75赋值给loadFactor,并没有创建数组
}
//在put的时候会进行扩容,第一次put就创建数组
- HashMap(int initialCapacity)
构造一个具有指定的初始容量和默认负载因子(0.75)HashMap 。
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//如果是10,向上取2的整数次幂,实际上是16
- HashMap(int initialCapacity, float loadFactor)
构造一个具有指定的初始容量和负载因子的 HashMap。
/*
指定“容量大小”和“负载因子”的构造函数
initialCapacity:指定的容量
loadFactor:指定的负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
// 判断初始化容量initialCapacity是否小于0
if (initialCapacity < 0)
// 如果小于0,则抛出非法的参数异常IllegalArgumentException
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
// 判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
// 如果超过MAXIMUM_CAPACITY,会将MAXIMUM_CAPACITY赋值给initialCapacity
initialCapacity = MAXIMUM_CAPACITY;
// 判断负载因子loadFactor是否小于等于0或者是否是一个非数值
if (loadFactor <= 0 || Float.isNaN(loadFactor))
// 如果满足上述其中之一,则抛出非法的参数异常IllegalArgumentException
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
// 将指定的负载因子赋值给HashMap成员变量的负载因子loadFactor
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
// 最后调用了tableSizeFor,来看一下方法实现:
/*
返回比指定初始化容量大的最小的2的n次幂
*/
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;
- HashMap(Map<? extends K, ? extends V> m)
包含另一个 “Map” 的构造函数
// 构造一个映射关系与指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) {
// 负载因子loadFactor变为默认的负载因子0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
最后调用了 putMapEntries(),来看一下方法实现:
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取参数集合的长度
int s = m.size();
if (s > 0) {
//判断参数集合的长度是否大于0,说明大于0
if (table == null) { // 判断table是否已经初始化
// 未初始化,s为m的实际元素个数
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
// 计算得到的t大于阈值,则初始化阈值
if (t > threshold)
threshold = tableSizeFor(t);
}
// 已初始化,并且m元素个数大于阈值,进行扩容处理
else if (s > threshold)
resize();
// 将m中的所有元素添加至HashMap中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
注意:
float ft = ((float)s / loadFactor) + 1.0F; 这一行代码中为什么要加 1.0F ?
s/loadFactor 的结果是小数,加 1.0F 与 (int)ft 相当于是对小数做一个向上取整以尽可能的保证更大容量,更大的容量能够减少 resize 的调用次数。所以 + 1.0F 是为了获取更大的容量。
例如:原来集合的元素个数是 6 个,那么 6/0.75 是8,是 2 的n次幂,那么新的数组大小就是 8 了。然后原来数组的数据就会存储到长度是 8 的新的数组中了,这样会导致在存储元素的时候,容量不够,还得继续扩容,那么性能降低了,而如果 +1 呢,数组长度直接变为16了,这样可以减少数组的扩容。
6.成员方法
- 增加方法put
put方法是比较复杂的,实现步骤大致如下:
1、 先通过 hash 值计算出 key 映射到哪个桶;
2、 如果桶上没有碰撞冲突,则直接插入;
3、如果出现碰撞冲突了,则需要处理冲突:
a.如果该桶使用红黑树处理冲突,则调用红黑树的方法插入数据;
b.否则采用传统的链式方法插入。如果链的长度达到临界值,则把链转变为红黑树;
4、如果桶中存在重复的键,则为该键替换新值 value;
5、如果 size 大于阈值 threshold,则进行扩容;
具体的方法如下:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
现在看 putVal 方法,看看它到底做了什么。
主要参数:
hash:key 的 hash 值
key:原始 key
value:要存放的值
onlyIfAbsent:如果 true 代表不更改现有的值
evict:如果为false表示 table 为创建状态
- 将链表转换为红黑树 treeifyBin()
结点添加完成之后判断此时结点个数是否大于 TREEIFY_THRESHOLD 临界值 8,如果大于则将链表转换为红黑树,转换红黑树的方法 treeifyBin,整体代码如下:
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//转换为红黑树 tab表示数组名 hash表示哈希值
treeifyBin(tab, hash);
- 扩容resize()
扩容机制:
- 什么时候才需要扩容
当 HashMap 中的元素个数超过数组大小(数组长度)*loadFactor(负载因子)时,就会进行数组扩容,loadFactor 的默认值是 0.75。
- HashMap 的扩容是什么
进行扩容,会伴随着一次重新 hash 分配,并且会遍历 hash 表中所有的元素,是非常耗时的。在编写程序中,要尽量避免 resize。
HashMap 在进行扩容时,使用的 rehash 方式非常巧妙,因为每次扩容都是翻倍,与原来计算的 (n - 1) & hash 的结果相比,只是多了一个 bit 位,所以结点要么就在原来的位置,要么就被分配到 “原位置 + 旧容量” 这个位置。
- 删除 remove() 方法:
删除方法就是首先先找到元素的位置,如果是链表就遍历链表找到元素之后删除。如果是用红黑树就遍历树然后找到之后做删除,树小于 6 的时候要转链表。
// remove方法的具体实现在removeNode方法中,所以我们重点看下removeNode方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
removeNode() 方法:
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
// 根据hash找到位置
// 如果当前key映射到的桶不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
// 如果桶上的结点就是要找的key,则将node指向该结点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
// 说明结点存在下一个结点
if (p instanceof TreeNode)
// 说明是以红黑树来处理的冲突,则获取红黑树要删除的结点
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 判断是否以链表方式处理hash冲突,是的话则通过遍历链表来寻找要删除的结点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// 比较找到的key的value和要删除的是否匹配
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 通过调用红黑树的方法来删除结点
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
// 链表删除
tab[index] = node.next;
else
p.next = node.next;
// 记录修改次数
++modCount;
// 变动的数量
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
- 查找方法 get()
查找方法,通过元素的 key 找到 value。
代码如下:
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
get 方法实现的步骤:
a. 通过 hash 值获取该 key 映射到的桶
b. 桶上的 key 就是要查找的 key,则直接找到并返回
c. 桶上的 key 不是要找的 key,则查看后续的结点:
如果后续结点是红黑树结点,通过调用红黑树的方法根据 key 获取 value
如果后续结点是链表结点,则通过循环遍历链表根据 key 获取 value
查找红黑树,由于之前添加时已经保证这个树是有序的了,因此查找时基本就是折半查找,效率更高。
这里和插入时一样,如果对比结点的哈希值和要查找的哈希值相等,就会判断key是否相等,相等就直接返回。不相等就从子树中递归查找。
若为树,则在树中通过key.equals(k)查找,O(logn)。若为链表,则在链表中通过key.equals(k)查找,O(n)。
- 遍历 HashMap 集合几种方式
- 分别遍历 Key 和 Values
for (String key : map.keySet()) {
System.out.println(key);
}
for (Object vlaue : map.values() {
System.out.println(value);
}
- Iterator迭代器
Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Object> mapEntry = iterator.next();
System.out.println(mapEntry.getKey() + "---" + mapEntry.getValue());
}
或
for(Map.Entry<String,Integer> entry:map.entrySet())