一、定义
hashMap是一种key,value关系型的集合,允许key,value为null值。无序,不可重复。效率高,线程不安全。底层采用数组+链表+红黑树存储数据(jdk8)。
二、构造方法、属性剖析
属性
// 默认初始容量为16 源码236行
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量 源码243行
static final int MAXIMUM_CAPACITY = 1 << 30;
// 加载因子默认值为0.75 源码248行
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 计数阈值,超过这个值将会使用树形结构替代链表结构
static final int TREEIFY_THRESHOLD = 8;
// 由树形结构转换成链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
// 树形结构最小的容量为64
static final int MIN_TREEIFY_CAPACITY = 64;
//链表数组
transient Node<K,V>[] table;
//HashMap中value的集合
transient Set<Map.Entry<K,V>> entrySet;
//HashMap的长度
transient int size;
//调整大小的下一个大小值
int threshold;
//hashtable的加载因子
final float loadFactor;
构造 不用过多关注
构造函数相对jdk7以前的版本而言有了显著的变化,并没有直接创建数组,而是在进行put操作的时候才真正创建数组用来存放数据。
1.public HashMap(int initialCapacity, float loadFactor)
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;
this.threshold = tableSizeFor(initialCapacity);
}
2.public HashMap(int initialCapacity)
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
3.public HashMap()
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
4.public HashMap(Map<? extends K, ? extends V> m)
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
put操作<关键>
public V put(K key, V value) {
// 计算准备添加key的hash值 调用putVal()
return putVal(hash(key), key, value, false, true);
}
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;
/* 将table赋值给新声明的tab 判断是否为null 或者n(tab的长度)的长度是否为0
初次添加table为null 进入第一次判断 调用resize()方法
*/
if ((tab = table) == null || (n = tab.length) == 0)
// n = 16
n = (tab = resize()).length;
//第一次p=tab[i=15&hash] // 为空 直接存
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
resize()
final Node<K,V>[] resize() {
// 创建一个老的Node数组接收table
Node<K,V>[] oldTab = table;
/*
判断老Node[] 是否为空 为空则取0,否则取原有的长度
*/
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 接收老的阈值
int oldThr = threshold;
// 创建新的长度、阈值
int newCap, newThr = 0;
// 判断老node[]的长度是否大于0 第一次 添加 小于0 跳过
if (oldCap > 0) {
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 第一次小于0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 第一次赋值操作 将16赋值给新的长度
newCap = DEFAULT_INITIAL_CAPACITY;
// 第一次赋值操作 计算阈值 0.75*16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 不成立
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 第一次 将12(0.75*16)赋值给将要扩容的阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 创建一个长度为16的Node[]新数组 并且赋值给table
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;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
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) {
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;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总结
从上面可以看出hashMap在添加元素的时候可以分为以下几步
首次
- 首先调用hash(key)【不深究此方法】,最大程度实现散列均匀,然后再调用putVal()
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
- 创建以下几个空对象
/*
entry从8开始被node替代
*/
Node<K,V>[] tab;//node数组
Node<K,V> p;//node节点
int n, i;
- 初始table为null 此判断成立 调用resize()方法
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
- 首先用一个新的对象接收老node数组中的值,(扩容需要)
Node<K,V>[] oldTab = table;
- 一系列的赋值操作
/*
判断老Node[] 是否为空 为空则取0,否则取原有的长度
*/
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 接收老的阈值
int oldThr = threshold;
// 创建新的长度、阈值
int newCap, newThr = 0;
- 为新的长度 和阈值进行赋值操作
newCap = DEFAULT_INITIAL_CAPACITY; //16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//.75*16
- 一系列的赋值操作,创建数组
// 更新阈值
threshold = newThr;
/*
此时 真正的创建了一个长度为16的node数组
*/
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 将新创建的newTab复制给table
table = newTab;
- 返回数组
return newTab;
- n的结果为16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
- 检查node[]该节点位置是否为null
// 第一次必然成立 直接添加
if ((p = tab[i = (n - 1) & hash]) == null)
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);
}
假设hash取值后该位置有重复的元素
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 创建
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 条件不成立 此时n为table的长度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 取最大索引值与hash进行&运算 同时为p赋值 检查该节点是否有数据 没有直接存
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//有数据
else {
Node<K,V> e; K k;
// 检查p的hash是否等于将要存放node的hash并且k与将要存放的k是否地址或者内容相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 此处相等则把p赋值给e
e = p;
// 判断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);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 有相同的元素则 跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 都不成立值赋给p
p = e;
}
}
// 如果e不为空(key相同)
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}