HashMap原理
Jdk1.7：
数据结构
数组 + 链表
初始容量、加载因子
默认初始容量为16，加载因子为0.75
put数据流程
插入数据流程：
1.判断数组是否为空数组，如果为空则会去初始化数组
2.判断传入的key是否为null，如果为null，调用putForNullKey(value)方法，插入null数据
3.计算出传入key的hash值
4.通过hash值计算该key存入的下标位置(hashCode & (length-1))
5.遍历该下标位置的链表，判断传入key是否存在hash值相等并且key相等的元素
6.如果key相等，将新传入的value覆盖旧的value
7.如果key不相等，则在该位置插入(hash, key, value, i)
8.插入数据前先判断是否需要扩容，如果需要，则扩容，并将旧数组的元素移动到新数组
9.插入数数据，创建entry对象(createEntry(hash, key, value, bucketIndex))，插入链表头部
10.插入成功后size++
put源码
public V put(K key, V value) {
if (table == EMPTY_TABLE) { // 判断数组是否为空数组，如果为空则会去初始化数组
inflateTable(threshold);
}
if (key == null) // 判断传入的key是否为null，如果为null，调用putForNullKey(value)方法插入空数据
return putForNullKey(value);
int hash = hash(key); // 计算传入key的hash值
int i = indexFor(hash, table.length); // 通过hash值计算该key存入的下标位置
for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 变量该下标位置的链表
Object k;
// 如果传入key的hash值与所在链表中数据的下标的hash值相等或者传入的key存在该链表中，将新的value替换旧的value，返回旧的value
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 添加数据（hash值，key，value，下标）
addEntry(hash, key, value, i);
return null;
}
inflateTable(threshold) ：初始化数组方法(阈值)
private void inflateTable(int toSize) {
// 找到一个大于等于toSize的2的n次方数
int capacity = roundUpToPowerOf2(toSize);
// 阈值 = （容量 * 加载因子）不指定初始化容量和加载因子时，默认初始化容量为16，加载因子为0.75， MAXIMUM_CAPACITY为最大容量
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
putForNullKey(value) ：插入key为空的数据
private V putForNullKey(V value) {
// 遍历第0位下标的链表，插入数据，如果已存在数据，则替换
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 插入数据（hash值为0，key为null，value，下标为0）
addEntry(0, null, value, 0);
return null;
}
indexFor(hash, table.length) ：计算存储下标位置
static int indexFor(int h, int length) {
// hash值 & （length - 1）
return h & (length-1);
}
addEntry(hash, key, value, i) ：添加数据
void addEntry(int hash, K key, V value, int bucketIndex) {
// 先判断是否需要扩容，当钱size > 阈值 且 当前要插入的下标位置不为空时
if ((size >= threshold) && (null != table[bucketIndex])) {
// 调用扩容方法，直接将数组长度翻倍
resize(2 * table.length);
// 扩容之后需要重新计算hash值，key为null的hash值为0
hash = (null != key) ? hash(key) : 0;
// 重新计算存储下标位置
bucketIndex = indexFor(hash, table.length);
}
// 创建对象存储（hash值，key，value，下标位置）
createEntry(hash, key, value, bucketIndex);
}
resize(2 * table.length); 扩容方法
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 判断原来数组是否为最大容量，如果是，则不再扩容， 默认最大容量是1 << 30
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 扩容, 创建新的数组
Entry[] newTable = new Entry[newCapacity];
// 将原来数组中的数据移动到新数组，并判断是否需要重新计算hash值
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
// 更新阈值和最大容量
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
transfer(newTable, initHashSeedAsNeeded(newCapacity)); 将原来数组中的数据移动到新数组
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
// 变量旧数组
for (Entry<K,V> e : table) {
// 判断当前数据是否为null
while(null != e) {
Entry<K,V> next = e.next;
// 判断是否重新计算hash值，key为null时不需要计算
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
// 重新计算存储下标位置
int i = indexFor(e.hash, newCapacity);
// 头插法插入数据
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
createEntry(hash, key, value, bucketIndex); 创建对象存储
void createEntry(int hash, K key, V value, int bucketIndex) {
// 获取原来当前下标位置数据，旧数据
Entry<K,V> e = table[bucketIndex];
// 创建对象到该下标数组(hash值，key，value，旧数据)
table[bucketIndex] = new Entry<>(hash, key, value, e);
// size统计
size++;
}
Jdk1.8：
数据结构
数组 + 链表 + 红黑树
初始容量、加载因子、树化阈值、树退化阈值
初始容量16，加载因子0.75，树化阈值8，数退化阈值6
put数据流程
插入数据流程：
-
调用putVal插入数据，并计算key的hash值
-
判断数组是否为空或长度为0，如果为空调用resize方法初始化数组
-
根据hash & (length - 1) 计算下标位置，并判断当前下标是否为空
-
如果为空，则将新的数组添加至当前位置
-
如果不为空，判断下标节点的hash值和key是否与添加的节点是否相同
-
如果相等，新值覆盖旧值
-
如果不相等，判断添加的节点是否为树节点
-
如果是树节点，将添加的节点加入树中
-
如果不是树节点且key值不与下标key相等，遍历所在下标位置链表
-
判断当前链表是否下一个元素是否为null，如果为null，则在链表尾部插入数据
-
插入数据后，再判断当前链表大小是否大于树化阈值，如果是，就将链表树化
-
判断插入的数据与链表中的其它数据key相等，则覆盖旧值
-
插入数据后就跳出循环，返回旧值，再判断是否需要扩容，扩容后结束
put源码
public V put(K key, V value) {
// 调用putVal方法（key的hash值，key，value。。。）
return putVal(hash(key), key, value, false, true);
}
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)
// 调用resize方法初始化数组
n = (tab = resize()).length;
// 计算下标，判断下标位置的数据是否为空
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果为空，将新的数据加入该下标位置
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 判断下表节点的hash值是否与添加节点的hash值相等， 或者key是否相等
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;
}
// 判断链表中当前节点是否与新加节点的key相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果旧节点数据不为null，返回旧节点值
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;
}
treeifyBin(tab, hash); 树化
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 判断数组是否为空，或者数组大小是否小于最小容量，如果满足，则进行扩容，不树化
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 判断下标位置节点是否为null
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
// 转换成树节点
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
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) {
// 判断旧数组长度是否大于最大容量，则不进行扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 如果就数组大小左移1小于最大容量 且 大于等于默认初始化容量，则将旧数组阈值左移1
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
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);
}
threshold = newThr;
@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;
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;
}
HashMap1.7和1.8的区别
1. 数据结构不同：1.7是数组+链表，1.8是数组+链表+红黑树
2. 插入数据方法不同：1.7是使用的头插法，在链表头部插入数据，在多线程环境下，会产生环形链表问题，1.8是使用的尾插法，在链表尾部插入数据，当链表大小>=8，且容量>64，就将链表树化，不会产生环形链表问题
3. 初始化方法不同：1.7的infateTable()负责创建，1.8中，resize()在表为空时负责创建
4. 扩容和插入数据顺序不同：1.7先扩容，再插入数据，会颠倒链表顺序，1.8先插入数据，再扩容，不会颠倒链表顺序
5. hash值计算逻辑不同：1.7基于key的hashcode返回值又进行了一些位运算，1.8直接拿key的hashcode做高低位异或操作
667
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
