-
摘要
HashMap简介
HashMap数据结构
HashMap源码解析
创造不易，转载请说明出处https://mp.csdn.net/mdeditor/82990695# -
HashMap简介:
HashMap是一个散列表，它的底层实现是链表数组，存储的结果为键值对，key-value形式,Key允许有一个null，value允许有多个null。
通过hash算法来快速定位该数据位于那条链表中。
HashMap继承自AbstractMap<K,V>，所以它是一个map,它实现了Map<K,V>接口，Cloneable 接口，和 Serializable接口。所以它可以被克隆和序列化。
HashMap是非同步的，也就是线程不安全的，在多线程环境中可以使用ConcurrentHashMap<K, V>来存储键值对。 -
HashMap数据结构:
在HashMap中通过数组链表来存储数据，它包含的属性有:
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;：默认容量16
static final int MAXIMUM_CAPACITY = 1 << 30：最大容量2^30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f: 默认加载因子0.75
static final int TREEIFY_THRESHOLD = 8; ：当链表长度大于等于8并且hashMap的容量大于等于64时变成红黑树
static final int UNTREEIFY_THRESHOLD = 6; ：当链表长度小于等于6时变成链表
static final int MIN_TREEIFY_CAPACITY = 64; ：当hashMap的容量达到64时可以被树化,这个值最少是TREEIFY_THRSHOLD的四倍。
transient Node<K,V>[] table;：是HashMap存储数据的结构，是一个链表数组，不被序列化
transient Set<Map.Entry<K,V>> entrySet;：是HashMap存储数据的一个视图，通过它可以查看hashMap中存储的数据。
transient int size ：HashMap中存储的key-value个数。
transient int modCount;：对HashMap结构的修改次数。用于快速失败。
int threshold; ：HashMap的闸值，用于判断是否需要改变容量，等于链表数组容量*加载因子
final float loadFactor; ：加载因子,默认0.75。一般不需要改动
HashMap使用Node<K,V>来存储键值对，它存储的有：key,value,hash,next它的结构为：
static class Node<K,V> implements Map.Entry<K,V> {
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;
}
}
- HashMap源码解析:
首先我们来看下HashMap的构造函数:
这个构造函数需要制定初始容量和加载因子，因为hashmap的扩容操作比较费时间，如果事先知道需要存储的容量时可以制定一个具体的容量，加载因子默认0.75，一般不需要改动。比较重要的有一个tableSizeFor()方法，它用来找一个合适的容量。
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//调用tableSizeFor()方法来给HashMap找到一个大于等于指定容量的最小容量，该容量为2的次方，也就是，16,32,64等。
this.threshold = tableSizeFor(initialCapacity);
}
下面上初始化代码比较简单，第一个调用上面那个构造器，指定初始容量，默认加载因子
第二个使用默认容量，默认加载因子
第三个把一个map加入新的HashMap中。
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
接下来我们看下tableSizeFor（int cap）方法，这个方法很短，也很精致。它接受一个int型参数，为用户输入的初始容量，返回一个大于等于输入参数的2的次方数。它的运算通过移位来完成，比如输入17,那么n=16也就是10000，首先让它和它>>>1或运算，得到11000,之后一样通过移位得到11110和11111最多移16位，因为int型最多有32位。
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;
}
之后我们来看get(Object key) 方法，它是通过getNode(int hash,Object key)来获取与key对应的value值。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
下面我们来看下getNode(int hash,Object key)方法，hashMap通过这个方法来获取value值。具体解析参考注释。这里提一点就是链表数组的长度始终为2的n次方，所以可以使用&运算来定位在哪一条链上，比如长度为16，hash值为1，那么在第一条链，hash为2在第二条链，hash值为16在第0条链等等，就是因为长度为2的n次方才可以这样计算。
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//定义tab来指向链表数组，first来指向key所在的链表的首位，n来表示链表数组的长度（2的n次方）
//当链表数组不为null,且长度大于零，使用(n-1)&hash来找出key所在的链表，这个&运算主要是因为链表数组的长度是2的n次方。
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//检查first节点是不是要找的节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//当first节点不是要找的节点时，遍历链表来查找key,链表有可能是一颗红黑树，当链表数组的长度大于等于64且链表的长度大于等于8时为红黑树。
if ((e = first.next) != null) {
//如果是红黑树，调用红黑树的查找方法。
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//不是红黑树时遍历链表即可
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
下面看containsKey(Object key)方法，它也是通过getNode(int hash,Object key)来实现的，即获取到的Node不为null,说明存在这个key。
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
下面我们看一下put方法
它里面实际上调用final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)方法来存储数据。
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)方法
//这个方法出现了两个新参数，onlyIfAbsent和evict,其中evict用来判断是初始化时传入的map的添加操作(false)或是在初始化完成后的添加操作（true），onlyIfAbsent参数表示是否允许覆盖原值，false表示允许覆盖，
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断是否未初始化，为了适应构造器中传入一个map情况
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//key计算出的那条链表为空时直接new一个Node加入即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//key所在的那条链不为空
else {
Node<K,V> e; K k;
//如果链表的第一个节点的key等于要出入数据的key
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//当链的长度大于等于8时会转换为红黑树，因为红黑树的存储结构不同，所有要区别对待
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//当key所在的链的首节点不等于key,遍历来寻找key，找到的话准备覆盖数据
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
//如果此条链的长度大于等于8时执行treeIfyBin()方法来判断是否需要转换成红黑树，转换红黑树的另一个条件是链表数组长度大于等于64，如果这两个条件都满足就转换，不满足第二个条件就扩容。
treeifyBin(tab, hash);
break;
}
//找到节点的key与要插入的key相等时跳出循环，准备覆盖数据
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;
//判断onlyIfAbsent是否为false，false运行覆盖数据，或节点的值为null允许覆盖数据
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//afterNodeAccess()方法默认为null实现，如果修改数据后需要别的工作的话重写这个方法即可。
afterNodeAccess(e);
return oldValue;
}
}
//结构修改次数加一
++modCount;
//如果此时链表数组的长度大于指定的闸值时，扩容。
if (++size > threshold)
resize();
//默认是null实现，允许我们插入数据完成后做一些事情
afterNodeInsertion(evict);
return null;
}
接下来看resize()方法，也就是扩容方法。这个方法比较长，它包括初始化时的扩容。
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) {
//如果原长度大于或等于MAXIMUM_CAPACITY(2^30)，则将threshold(闸值)设为Integer.MAX_VALUE大约为MAXIMUM_CAPACITY(2^30)的二倍
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
}
//老的链表数组长度小于等于0，老的闸值大于零，这种情况是初始化时传入一个map导致的构造器为public HashMap(Map<? extends K, ? extends V> m)
else if (oldThr > 0) // initial capacity was placed in threshold
//让新的容量等于旧的闸值
newCap = oldThr;
//下面的else是默认的构造器，即public HashMap()
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//新的闸值为零时（也就是(newCap = oldCap << 1) >= MAXIMUM_CAPACITY的情况），这时需要赋予newThr正确的值。
if (newThr == 0) {
float ft = (float)newCap * loadFactor; //闸值=链表数组长度*加载因子。
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
//扩容，如果原来的链表数组中有数据，就复杂到table中
@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;
//当oldTab[j]这条链不为空时
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果这条链只有首节点有数据，把它添加进新链表数组中
if (e.next == null)
//因为数组的容量时2的n次方，所以使用hash&(newCap-1)来计算出在那条链中。
newTab[e.hash & (newCap - 1)] = e;
//如果老的链在红黑树中，使用split()方法来复制
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//当前链中不只只有一个链表头数据时，遍历链表来复制
else { // preserve order
//数据的复制有两种情况，第一种是原位置不变，第二种是位置改变
loHead代表和原链相同位置的链，hiHead代表是原链加上原容量的链，因为扩容后长度为原长度的二倍，一个链中的节点要不在原位置的链中，要么在原位置加原容量的链中
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//通过e.hash和oldCap进行&运算来得出位置是否需要改变。
比如原数组容量为16（10000）和hash值进行&运算，如果高位1未参加运算，则为0即位置不变，如果高位参加了运算值不等于0,需要改变位置。
//loHead和hiHead分别代表原位置的链和新位置的链
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
//原位置为j
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
//新位置为j+oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
基本上HashMap常用的方法都看完了，相信你看完后对HashMap容器有了更深层次的认识。