看源码前要明确一个基础知识，HashMap是 数组 + 链表 + 红黑树的 数据结构。
存储数据时会先通过hash值判断存在数组哪个位置上，如果当前位置已经有数据了，就在其后面形成链表，当链表长度大于8时就会将链表转换成红黑树，提升查询速度。
下图是一个数据结构示意图。稍微有点简陋，但是要表达的意思已经传递出去了。
由于HashMap中有大量的红黑树的操作，难度系数是很高的，所以没有包含这些内容，怕误人子弟，所以只介绍平时用的较多的方法
get方法 通过key获取value 和 containsKey 方法 判读集合中是否包含某个值
public V get(Object key) {
//创建一个节点对象
Node<K,V> e;
//很明现调用了getNode方法，下面我们看一下
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//和上面的方法一样调用了相同的方法
public boolean containsKey(Object key) {
//判断是否包含某个值
return getNode(hash(key), key) != null;
}
//这个方法会根据传进来的hash值计算数组的位置，如果数组的第一个节点不符合要求就继续对比数组后的链表（当然前提是链表存在的话）
final Node<K,V> getNode(int hash, Object key) {
//tab用于存储table这个Node数组，table是HashMap声明的一个变量，只要HashMap中有数据 table中就有元素
//first为了储存第一个节点的数据
//e 用于后续循环
//K为键
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断 table不为空，table的长度大于零，tab[(n - 1) & hash]用于找到第一个元素的节点 第一个节点也不为空。
//这些判断都是为了证明集合不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//先用第一个节点的hash进行对比，如果相同就返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//如果不存在就取第一个节点的链表中寻找
if ((e = first.next) != null) {
//如果链表是红黑树就调用红黑树的方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果不是红黑树就进行循环，直到把所有链表都对比过。如果有相同的值就返回值，没有就返回null
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}put方法，存入某值
public V put(K key, V value) {
//hash(key)代表根据key计算hash值
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;
//table 是HashMap的总节点数组，如果它为空 说明HashMap没有被初始化
if ((tab = table) == null || (n = tab.length) == 0)
//没有被初始化就会调用扩容方法resize 进行初始化
n = (tab = resize()).length;
//通过参数hash，根据i = (n - 1) & 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))))
//满足条件将P赋值给中间变量 e
e = p;
//如果满足条件说明数组后面形成的是红黑树结构
else if (p instanceof TreeNode)
//红黑树的方法
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//上面的条件都不满足说明数据存储在链表中
for (int binCount = 0; ; ++binCount) {
//如果满足条件说明p 位置是链表最后一个元素
if ((e = p.next) == null) {
//直接在它后面添加新节点
p.next = newNode(hash, key, value, null);
//如果长度满足条件就转为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//跳出循环
break;
}
//e是在上面的判断语句e = p.next 中赋值的
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//每循环一次就将p 赋值给e e也就等于p.next
p = e;
}
}
//满足条件说明存在哈希冲突的值
if (e != null) { // existing mapping for key
//提取节点e 的值
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//替换e节点的值，完成数据的覆盖
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//判断是否要扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}putAll 方法 合并两个HashMap集合（里面有一个map循环需要注意）
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
//以上代码都是进行扩容的，不做赘述（因为不懂，不敢瞎说)
//所以下面的这段代码重点看
//m.entrySet()方法会返回所有节点对象，然后对所有节点对象进行遍历
//HashMap的循环方法建议按下面的写，如果数据量很大的话就能够看出他的性能很好
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//调用HashMap的添加方法,这个方法上面说过
putVal(hash(key), key, value, false, evict);
}
}
}remove 方法 删除一个元素
public V remove(Object key) {
Node<K,V> e;
//调用了removeNode方法
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//满足条件说明 HashMap集合不是null，同时要删除的值也存在
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//p已经被赋值为要删除的节点对象，如果满足条件（hash值相同，key值也相同）则说明找到了要删除的值，并且这个值在数组中
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//将目标节点赋值给中间值 node
node = p;
//走到这里说明元素不在数组上， 如果满足条件说明数组后面存在链表或者红黑树
else if ((e = p.next) != null) {
//如果满足说明是红黑树节结构
if (p instanceof TreeNode)
//调用红黑树的方法找到要删除的节点对象
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//如果走到这里说明元素存储在链表中
else {
//遍历整个链表
do {
//如果满足条件说明找到了，将节点对象赋值给node
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//判断节点对象是否满足条件
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是红黑树就调用红黑树的方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果在数组中直接让index位置的节点对象指向要删除对象的下一个节点对象，越过要删除的元素
else if (node == p)
tab[index] = node.next;
//在链表中的处理方法跟在数组中的方式很相似，不过P是目标对象的上一个节点对象。
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}clear方法 清空集合元素
public void clear() {
//创建节点对象数组以接收HashMap的节点数组
Node<K,V>[] tab;
modCount++;
//如果满足条件说明集合中有元素
if ((tab = table) != null && size > 0) {
//将集合长度清零
size = 0;
//遍历每一个节点并清空
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
