好久没有更新文章目录了，今天正好在家休息，就整理了下（绿色字体表示已经完成或者进行中，黑色字体表示规划中），大家有什么好的建议欢迎踊跃评论（下午要是来得及可能会分享一篇关于业务管理流程BPM系统的产品解决方案）：

今天准备分享之前面试时的一个笔记，一般去专业点的IT公司面试中高级开发岗时，面试官都会问的比较底层，我很多同学也有类似的经验，因为平时也很少看这种底层的东西，所以之前很多意向的公司就这样擦肩而过。前两天有有些同事跳槽面试的时候好像又碰到类似的问题，所以我翻出以前的日记分享给大家。但是这种笔记都是偏理论性质会比较多，没有特别多的可读性，先拿出来给大家看看，如果喜欢的人多，我后面再加更，话不多说直接开始聊一下jdk1.8 HashMap的一些琐碎：
构造方法
1、new HashMap() 无参数构造方法，只赋值了一个加载因子，默认的加载因子0.75f。

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;
}
3、new HashMap(Map<? extends K, ? extends V> m) 有初始化数据的HashMap 会对内容进行重新放到新的数组和链表里面，具体细节可以参看put 方法
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
// 根据初始化的map的大小，算出扩容需要的阈值，如果大于阈值，需要初始化数组大小。
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();
// 将初始化map 放到新的数组和链表中。
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}}

put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 数组的大小小于64的话，还是只是会扩容，不会做树化。
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
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);
}
}

get方法
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;
// 判断数组不为空，且数组上第一个元素不为空的情况
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// key 是否和传入的一致
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);
// 如果是链表的话，遍历整个链表查询到key 一致就返回。
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

remove方法
public V remove(Object key) {
Node<K,V> e;
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;
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;
// 看数组上头结点是不是 需要移除的节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
// 头结点的next 节点是不是树节点，树节点的话，需要从树上找到这个结点
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 链表里面找到对应结点
do {
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);
else if (node == p)// 如果是头结点就直接替换
tab[index] = node.next;
else
// 链表移除结点
p.next = node.next;
++modCount;
–size;
afterNodeRemoval(node);
return node;
}
}
return null;
}

花有重开日，人无再少年 → 我是花少【少宫主花无缺】#更新不断，创作不易#走过路过不不白piao，留下关注和点赞（公众号同名）@all