HashMap
Posted 364.99°
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了HashMap相关的知识，希望对你有一定的参考价值。
目录
1.简介
-
存储形式：key-value（key唯一，value可重复，两者都可为null，但key至多有一个null）
-
无序存储
-
HashMap 的实现不是同步，非线程安全类
-
jdk1.8 之前 HashMap 由 数组 + 链表组成
数组——主体
链表——解决多个对象调用的地址冲突（拉链法）
-
jdk1.8 之前 HashMap 由 数组（主体） + 链表/红黑树组成
红黑树——链表长度大于阈值（或者红黑树的边界值，默认为 8 ）&&当前数组的长度大于 64 ，使用红黑树储存
数组扩容——考虑到效率，当上述条件非全部满足时，使用数组扩容
2.新数据的存储过程
hash表底层采用的计算hash表的算法： key的hashcode方法的值结合数组长度进行无符号右移（>>>）、按位异或（^）、按位与（^）计算出索引
不考虑效率，还可采用的方法： 平方取中法、取余数、伪随机数法
HashMap<Integer,String> map1 = new HashMap<>();
map1.put(1,"张三");
map1.put(2,"李四");
map1.put(2,"王五");//会覆盖掉之前的张三
System.out.println(map1);
-
HashMap 的构造方法是在第一次调用 put 方法时创建数组（长度16） Node[] table来存储键值对数据。
-
在像hash表中存储数据时，若计算出的索引的索引空间没有数据，就将数据存到数组中
-
索引空间有数据，就在此空间上划出一个节点来存储键值对数据
-
key重复时（hash碰撞），可知计算出的存储位置不变，会覆盖之前的value
小结
- 当两个对象对象的 hashcode相等（hash碰撞） 时（调用equals()比较key）
key相同： 覆盖之前的value
key不同： 接到链表之后，链表>阈值8且数组长度>64，采用红黑树存储（O(logn)），链表(O(n))
- 当不断添加数据，超出临界值时，采用扩容，默认为原来容量的两倍
创建一个新的数组，创建一个新的数组，长度是原来的 2倍
遍历旧表的元素，重新计算hashcode并插入到新表- put的全过程
size： HashMap 中键值对的实时数量
threshold（临界值）： 当前已占用数组长度的最大值， threshold（临界值）= capacity（容量）* loadFactor（负载因子）
3.集合类的成员变量
3.1 继承关系
- Cloneable 空接口，表示可以克隆。创建并返回 HashMap 对象的一个副本。
- Serializable 序列化接口。属于标记性接口。HashMap 对象可以被序列化和反序列化。
- AbstractMap 父类提供了 Map 实现接口。以最大限度地减少实现此接口所需的工作。
3.2 成员变量
serialVersionUID——序列化版本号
private static final long serialVersionUID = 362498820763181265L;
DEFAULT_INITIAL_CAPACITY——集合的初始化容量（必须为2^n）
// 默认的初始容量是16 1 << 4 相当于 1*2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
HashMap 为了存取高效，减少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现的关键就在把数据存到哪个链表中的算法。
算法： hash % length，hash值，数组长度
因为取余效率不如位运算，计算机对齐进行了优化
优化后的算法： hash & ( length - 1)
优化算法的前提： length = 2^n
/**
* Returns a power of two size for the given target capacity.
*/
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 实例时，如果给定了 initialCapacity，由于 HashMap 的 capacity 必须都是 2 的幂，因此这个方法用于找到>= initialCapacity 的最小的 2 的幂
最终得到的这个 capacity 被赋值给了 threshold
this.threshold = tableSizeFor(initialCapacity);
指定集合的初始容量
// 构造一个带指定初始容量和默认负载因子（0.75)的空 HashMap。
HashMap(int initialCapacity)
DEFAULT_LOAD_FACTOR——默认加载因子（0.75）
static final float DEFAULT_LOAD_FACTOR = 0.75f;
MAXIMUM_CAPACITY——集合最大容量
static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次幂
TREEIFY_THRESHOLD——当链表的值超过8则会转为红黑树（jdk1.8新增）
// 当桶（bucket）上的结点数大于这个值时会转为红黑树
static final int TREEIFY_THRESHOLD = 8;
Map桶中节点超过8转为红黑树：
TreeNodes 占用空间是普通 Nodes 的两倍
泊松分布
链表长度达到 8 就转成红黑树，当长度降到 6 就转成普通 bin（bin就是 bucket 桶）→权衡空间和时间
* Because TreeNodes are about twice the size of regular nodes, we
* use them only when bins contain enough nodes to warrant use
* (see TREEIFY_THRESHOLD). And when they become too small (due to
* removal or resizing) they are converted back to plain bins. In
* usages with well-distributed user hashCodes, tree bins are
* rarely used. Ideally, under random hashCodes, the frequency of
* nodes in bins follows a Poisson distribution
* (http://en.wikipedia.org/wiki/Poisson_distribution) with a
* parameter of about 0.5 on average for the default resizing
* threshold of 0.75, although with a large variance because of
* resizing granularity. Ignoring variance, the expected
* occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
* factorial(k)). The first values are:
*
* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
* more: less than 1 in ten million
UNTREEIFY_THRESHOLD——树转表的节点个数阈值
// 当桶（bucket）上的结点数小于这个值，树转为链表
static final int UNTREEIFY_THRESHOLD = 6;
MIN_TREEIFY_CAPACITY——表转树的数组长度阈值
// 桶中结构转化为红黑树对应的数组长度最小的值
static final int MIN_TREEIFY_CAPACITY = 64;
table——初始化hash表（2^n）
// 存储元素的数组
transient Node<K,V>[] table;
table 就是 HashMap 中的数组，jdk8 之前数组类型是
Entry<K,V>类型。从 jdk1.8 之后是Node<K,V>类型。都实现了Map.Entry<K,V>接口，仅名字不同。
entrySet——存放缓存
// 存放具体元素的集合
transient Set<Map.Entry<K,V>> entrySet;
size——表中元素个数
// 存放元素的个数，注意这个不等于数组的长度
transient int size;
size代表 键值对数量，不是数组的长度
modCount——表的修改次数
// 每次扩容和更改 map 结构的计数器
transient int modCount;
threshold——扩展临界值
// 临界值 当实际大小（容量*负载因子）超过临界值时，会进行扩容
int threshold;
threshold（临界值）= capacity（容量）* loadFactor（负载因子）
loadFactor——表的负载因子
// 负载因子
final float loadFactor;
加载因子：
取值0~1之间，用来衡量 HashMap 满的程度（表示HashMap的疏密程度），越靠近1越满（密），影响hash 操作到同一个数组位置的概率
计算 HashMap 的实时负载因子：
size/capacity,capacity——数组的长度
影响：
太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散，0.75f 是官方给出的一个比较好的临界值
扩容：
表中元素达到 HashMap 数组长度的 75% 时，表示 HashMap 太挤了，需要扩容，而扩容这个过程涉及到 rehash、复制数据等操作，非常消耗性能。开发中，为减少扩容，通常在创建hashmap对象时指定初始容量
定制：
HashMap 的构造器中可以定制 loadFactor
HashMap构造器
// 构造方法，构造一个带指定初始容量和负载因子的空HashMap
HashMap(int initialCapacity, float loadFactor);
3.3 构造方法
HashMap()——默认初始容量（16）默认负载因子（0.75）
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 将默认的负载因子0.75赋值给loadFactor，并没有创建数组
}
HashMap(int initialCapacity)——指定初始容量（>=指定容量的最小的2^n），默认负载因子（0.75）
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
HashMap(int initialCapacity, float loadFactor)——指定初始容量与负载因子
/*
指定“容量大小”和“负载因子”的构造函数
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 ？
扩大容量，尽量减少扩容（resize）次数
4.成员方法
4.1 put()
实现步骤：
- 由 hash 值计算出 key 映射到哪个桶；
- 桶上没有hash碰撞，则直接插入；
- 有hash碰撞：
3.1 如果该桶使用红黑树处理冲突，则调用红黑树的方法插入数据；
3.2 否则采用传统的链式方法插入。如果链的长度达到临界值，则把链转变为红黑树； - 桶中存在重复的键，则为该键替换新值 value；
- size 大于阈值 threshold，则进行扩容
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
putVa()l负责—put的元素插入，调用了一个方法hash()
可见：key可以为空，返回为0，key不为空，就计算hashCode并赋值给h，再将h无符号右移16位和hashCode进行按位异或得到最终的hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
接下来，根据上述代码计算出的hashCode计算索引
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
...
if ((p = tab[i = (n - 1) & hash]) == null) // 这里的n表示数组长度16
...
}
小结——计算hash值
key.hashCode()计算hashCodekey.hashCode()^(key.hashCode()>>>16)计算出hash值
即：高16位保持不变，低16位与高16位异或
目的： 将高位地位都利用起来，解决hash碰撞
当数组长度很小时，与hashCode直接进行按位与操作，表的利用率极低。当hash值高位变化很大，低变化很小，这样就容易导致hash碰撞。
putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
/*
1）transient Node<K,V>[] table; 表示存储Map集合中元素的数组。
2）(tab = table) == null 表示将空的table赋值给tab，然后判断tab是否等于null，第一次肯定是null。
3）(n = tab.length) == 0 表示将数组的长度0赋值给n，然后判断n是否等于0，n等于0，由于if判断使用双或，满足一个即可，则执行代码 n = (tab = resize()).length; 进行数组初始化，并将初始化好的数组长度赋值给n。
4）执行完n = (tab = resize()).length，数组tab每个空间都是null。
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/*
1）i = (n - 1) & hash 表示计算数组的索引赋值给i，即确定元素存放在哪个桶中。
2）p = tab[i = (n - 1) & hash]表示获取计算出的位置的数据赋值给结点p。
3) (p = tab[i = (n - 1) & hash]) == null 判断结点位置是否等于null，如果为null，则执行代码：tab[i] = newNode(hash, key, value, null);根据键值对创建新的结点放入该位置的桶中。
小结：如果当前桶没有哈希碰撞冲突，则直接把键值对插入空间位置。
*/
if ((p = tab[i = (n - 1) & hash]) == null)
// 创建一个新的结点存入到桶中
tab[i] = newNode(hash, key, value, null);
else {
// 执行else说明tab[i]不等于null，表示这个位置已经有值了
Node<K,V> e; K k;
/*
比较桶中第一个元素(数组中的结点)的hash值和key是否相等
1）p.hash == hash ：p.hash表示原来存在数据的hash值 hash表示后添加数据的hash值 比较两个hash值是否相等。
说明：p表示tab[i]，即 newNode(hash, key, value, null)方法返回的Node对象。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
而在Node类中具有成员变量hash用来记录着之前数据的hash值的。
2）(k = p.key) == key ：p.key获取原来数据的key赋值给k key 表示后添加数据的key比较两个key的地址值是否相等。
3）key != null && key.equals(k)：能够执行到这里说明两个key的地址值不相等，那么先判断后添加的key是否等于null，如果不等于null再调用equals方法判断两个key的内容是否相等。
*/
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
/*
说明：两个元素哈希值相等，并且key的值也相等，将旧的元素整体对象赋值给e，用e来记录
*/
e = p;
// hash值不相等或者key不相等；判断p是否为红黑树结点
else if (p instanceof TreeNode)
// 放入树中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 说明是链表结点
else {
/*
1)如果是链表的话需要遍历到最后结点然后插入
2)采用循环遍历的方式，判断链表中是否有重复的key
*/
for (int binCount = 0; ; ++binCount) {
/*
1)e = p.next 获取p的下一个元素赋值给e。
2)(e = p.next) == null 判断p.next是否等于null，等于null，说明p没有下一个元素，那么此时到达了链表的尾部，还没有找到重复的key,则说明HashMap没有包含该键，将该键值对插入链表中。
*/
if ((e = p.next) == null) {
/*
1）创建一个新的结点插入到尾部
p.next = newNode(hash, key, value, null);
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
注意第四个参数next是null，因为当前元素插入到链表末尾了，那么下一个结点肯定是null。
2）这种添加方式也满足链表数据结构的特点，每次向后添加新的元素。
*/
p.next = newNode(hash, key, value, null);
/*
1)结点添加完成之后判断此时结点个数是否大于TREEIFY_THRESHOLD临界值8，如果大于则将链表转换为红黑树。
2）int binCount = 0 ：表示for循环的初始化值。从0开始计数。记录着遍历结点的个数。值是0表示第一个结点，1表示第二个结点。。。。7表示第八个结点，加上数组中的的一个元素，元素个数是9。
TREEIFY_THRESHOLD - 1 --》8 - 1 ---》7
如果binCount的值是7(加上数组中的的一个元素，元素个数是9)
TREEIFY_THRESHOLD - 1也是7，此时转换红黑树。
*/
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 转换为红黑树
treeifyBin(tab, hash);
// 跳出循环
break;
}
/*
执行到这里说明e = p.next 不是null，不是最后一个元素。继续判断链表中结点的key值与插入的元素的key值是否相等。
*/
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 相等，跳出循环
/*
要添加的元素和链表中的存在的元素的key相等了，则跳出for循环。不用再继续比较了
直接执行下面的if语句去替换去 if (e != null)
*/
break;
/*
说明新添加的元素和当前结点不相等，继续查找下一个结点。
用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
*/
p = e;
}
HashMap原理:哈希函数的设计