关于HashMap很多人都或多或少有些了解，因为这次跳槽面试的公司都有问到其中的一些原理，所以重新阅读一遍原理，并记录下来，主要从HashMap的各个成员变量和方法展开。
目录
概述
HashMap是一个散列表，用来存储key-value的数据结构。HashMap的底层是通过一个数组加链表来实现的，在Java8之后还引入了红黑树来进行优化。HashMap不是一个线程安全的类，所以在并发场景下最好要考虑清楚，再使用该类（线程不安全的原因在后续会说明）。
数组中的元素通常称为bin（桶）,数组长度也叫做桶数。
底层数据结构
底层的数据结构见下图，主要的是一个数组table，以及一个一个链表。
//数组
transient Node<K,V>[] table;
//持有所有Node的Set，详见entrySet方法，主要用于迭代器。
transient Set<Map.Entry<K,V>> entrySet;
Node源码
Node是HashMap的一个内部类，实现了Entry接口，在HashMap的数组中储存的就是一个个Node（或者可以说Entry）。它的组成最主要的就是hash值、key、value以及下一个节点的引用。源码如下，以作详细注释。
static class Node<K,V> implements Map.Entry<K,V> {
//hash值
final int hash;
//键
final K key;
//值
V value;
//下一个节点
Node<K,V> next;
//构造函数
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
//返回该node的key
public final K getKey() { return key; }
//返回该node的value
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
//计算hashCode
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//判断节点是否相等
public final boolean equals(Object o) {
//如果是同一个引用直接返回
if (o == this)
return true;
//先判断是否为Entry类型，如果是，在判断key和value是否相等
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
成员变量介绍
- transient int size
HashMap中保存了有多少个Node - transient int modCount;
这个值和并发中的fail-fast策略有关系，如果在对该hashmap进行遍历的时候，有其他线程对该hashmap进行操作，那么就会直接抛出一个ConcurrentModificationException - int threshold;
当size达到这个值的时候，就需要进行扩容操作，这个值等于该map容量与loadFactor的乘积，即threshold=capacity*loadfactor - float loadFactor;
加载因子，默认值为0.75 - int DEFAULT_INITIAL_CAPACITY
默认初始化容量，1<<4,即16 - int MAXIMUM_CAPACITY
极限容量，为2^30次方 - float DEFAULT_LOAD_FACTOR
默认加载因子0.75 - int TREEIFY_THRESHOLD
当一个链表当长度超过这个值，并且size大于MIN_TREEIFY_CAPACITY的时候就进行树化 - int UNTREEIFY_THRESHOLD
解除树化的长度 - int MIN_TREEIFY_CAPACITY
只有size大于这个值才进行树化
方法介绍（核心方法）
构造函数
HashMap最常用的构造方法就是
- HashMap(int initialCapacity):
initialCapacity就是HashMap的容量大小。这也是阿里巴巴开发手册里推荐的初始化方法。以下内容引用自《阿里巴巴Java开发手册》
【推荐】集合初始化时，指定集合初始值大小。
说明：HashMap 使用 HashMap(int initialCapacity) 初始化。
正例：initialCapacity=(需要存储的元素个数/负载因子)+1。注意负载因子（即loaderfactor）默认为0.75，如果暂时无法确定初始值大小，请设置为16（即默认值）。
反例：HashMap 需要放置1024个元素，由于没有设置容量初始大小，随着元素不断增加，容量7次被迫扩大，resize 需要重建 hash 表，严重影响性能。- HashMap():
HashMap默认无参构造函数，初始容量为16，负载因子为0.75 - HashMap(int initialCapacity, float loadFactor)
loadFactor指定负载因子，当size>=capacity*loadfactor的时候，就需要进行扩容操作了。
hash
hash方法是HashMap为了减少hash碰撞的概率而写的“扰动函数”。具体原理点这里看。
在get方法和put方法中，要找到对应数组下标，都是先用这个方法计算出key的hash值（int类型），然后再用这个hash值与数组长度进行与运算，得到相应的数组下标，进行后续的操作。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public V put(K key,V value)
put方法就是往容器中存储一个entry，即一个键值对数据。最主要的操作，都是在putVal方法里实现的。putVal的几个参数值代表了什么意思呢。 put在1.7和1.8中的实现方法有点区别，想了解1.7的可以自己去看。
- hash：key的hash值。
- key：key-键
- value：value-值
- onlyIfAbsent：如果为true的话，那put的时候就不会改变已存在的值，默认为false。
- evicet：HashMap中没有用到，感兴趣可查看LinkedHashMap源码
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;
// 如果数组为空，或者数组长度为0，那么进行一次扩容。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//Hash和数组长度进行 与 运算，如果计算到的位置为空，那么就直接放到该位置上。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//计算到的数组中有元素，这里的e保存的是旧值。
Node<K,V> e; K k;
// 第一个元素就是要处理的值，后续会判断是否替换
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的话，那么说明这个HashMap中存在了相同的key
if (e != null) {
V oldValue = e.value;
//这里就需要到了这个 onlyIfAbsent 参数了，默认false，所以直接将旧节点的值替换了。
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//因为原本就存在这个key了，那么这时候就直接返回旧值
return oldValue;
}
}
++modCount;
//
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
以下为put方法的总体流程图
V get(Object key)
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 判断数组不为空的话->数组长度不为0->根据key的hash值算出来的下标的元素不为空，如果都满足则继续找，否则直接返回。
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//找到key所对应的那个bin，先判断第一个值是不是要get的，如果是就返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//如果是TreeNode。调用TreeNode的getTreeNode遍历寻找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//遍历链表，寻找要get的值
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
resize
resize方法就是HashMap的扩容方法。初始化HashMap（HashMap刚new出来的时候容量为0，只有第一次put的时候才会调用resize初始化）或者把原本的容量扩容一倍。
final Node<K,V>[] resize() {
//oldTab指向原来的数组
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//原来的容量如果大于0，说明HashMap里已经有值了
if (oldCap > 0) {
//旧的容量如果已经大于最大容量，那直接把threshold直接置最大，不扩容直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//容量和threshold都直接变为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//这是带参数的初始化方法，就直接将新容量初始化为threshold。带参数的构造方法会将threshold的值置为初始容量。
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//如果threshold和原容量都是0，说明要进行初始化
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//计算完新的容量之后，更新新的threshold
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//更新
threshold = newThr;
//扩容算法中比较核心的部分，就是新建一个数组，并将原来的HashMap中的元素复制到新的数组中去。
@SuppressWarnings({"rawtypes","unchecked"})
//新建一个数组，数组初始化长度为上面得到的“newCap”。
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;
//找到一个bin不为空，进行后续操作
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果这个bin中只有一个元素，那么直接对这个节点进行复制，也就是通过上面介绍的hash方法来计算新的下标。
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果这个bin后面是树，那么调用TreeNode的split方法进行复制。
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
//这个bin后面是链表，遍历链表进行复制。
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) {
// 对应的bin中没有元素，直接将那个元素放到bin中
if (loTail == null)
loHead = e;
else
// 原本的bin中已经有链表了，那么直接跟在链表尾部
loTail.next = e;
loTail = e;
}
//如果节点在新数组中的位置需要改变，那么就记录在hiHead这个链表中。后续处理
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;
}
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
