这里就不记录一些面试题了。。如果能够理解源码那什么牛鬼蛇神面试题都应该不在话下了

主要是作为一个笔记来记录，参考的原博：
https://thinkwon.blog.csdn.net/article/details/103592572?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.add_param_isCf&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.add_param_isCf

看源码的话，主要还是三个方面吧

1. 继承结构
2. 构造方法
3. 常用方法

ArrayList解析

ArrayList的特点：

1. 基于数组实现
2. 可以动态调整容量
3. 有序
4. 元素可以为null
5. 非线程安全
6. 查询快，增删慢
7. 占用空间更小（对比LinkesList）

继承关系

从ArrayList的源码中也可以看到，ArrayList继承了AbstractList，实现了 List, RandomAccess, Cloneable, java.io.Serializable接口。RandomAccess表示了实现类支持快速随机访问，Cloneable表示实现类支持克隆，具体的表现方法为重写了clone（）方法。 java.io.Serializable表示支持序列化。

成员变量

从上之下分别是：序列号，数组初始化容量为10，空对象数组，缺省空对象数组，底层数据结构（数组），数组元素个数（默认为0），最大数组容量

构造方法

//默认构造方法，初始为空数组。
//只有插入一条数据后才会扩展为10，而实际上默认是空的public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}//根据指定容量创建对象数组
public ArrayList(int initialCapacity) {if (initialCapacity > 0) {//创建initialCapacity大小的数组this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {//创建空数组this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}
}/*** 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。*/
public ArrayList(Collection<? extends E> c) {//转换最主要的是toArray()，这在Collection中就定义了elementData = c.toArray();if ((size = elementData.length) != 0) {// c.toArray 有可能不返回一个 Object 数组if (elementData.getClass() != Object[].class)//使用 Arrays.copy 方法拷创建一个 Object 数组elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// 替换为空数组this.elementData = EMPTY_ELEMENTDATA;}
}

无参构造方法创建ArrayList时，实际上初始化的是一个空数组，只有在对数组进行添加元素的时候，才真正的分配容量。即向数组中添加第一个元素的时候，数组扩容为10

内部类

(1)private class Itr implements Iterator<E>
(2)private class ListItr extends Itr implements ListIterator<E>
(3)private class SubList extends AbstractList<E> implements RandomAccess
(4)static final class ArrayListSpliterator<E> implements Spliterator<E>

ArrayList有4个内部类，其中Itr实现了Iterator接口，重写了hashNext（），next（），remove（）等方法。ListLtr继承了Itr，实现了ListIterator接口，重写了hasPrevious（），nextIndex（），previousIndex（），previous（），set（E e），add（E e）等方法。
所以由此也可以看出来Iterator和ListIterator的区别：ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向便利等方法，这些是Iterator不能实现的。

核心方法

add（）

//添加一个特定的元素到list的末尾
public boolean add(E e) {//先确保elementData数组的长度足够，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个个数数组能否放得下，在这个方法中去判断数组长度是否够用ensureCapacityInternal(size + 1);  // Increments modCount!!//在数据中正确的位置上放上元素e，并且size++elementData[size++] = e;return true;
}//在指定位置添加一个元素
public void add(int index, E element) {rangeCheckForAdd(index);//先确保elementData数组的长度足够ensureCapacityInternal(size + 1);  // Increments modCount!!//将数据整体向后移动一位，空出位置之后再插入，效率不太好System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++;
}// 校验插入位置是否合理
private void rangeCheckForAdd(int index) {//插入的位置肯定不能大于size 和小于0if (index > size || index < 0)   //如果是，就报越界异常throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}//添加一个集合
public boolean addAll(Collection<? extends E> c) {//把该集合转为对象数组Object[] a = c.toArray();int numNew = a.length;//增加容量ensureCapacityInternal(size + numNew);  // Increments modCount//挨个向后迁移System.arraycopy(a, 0, elementData, size, numNew);size += numNew;//新数组有元素，就返回 truereturn numNew != 0;
}//在指定位置，添加一个集合
public boolean addAll(int index, Collection<? extends E> c) {rangeCheckForAdd(index);Object[] a = c.toArray();int numNew = a.length;ensureCapacityInternal(size + numNew);  // Increments modCountint numMoved = size - index;//原来的数组挨个向后迁移if (numMoved > 0)System.arraycopy(elementData, index, elementData, index + numNew,numMoved);//把新的集合数组 添加到指定位置System.arraycopy(a, 0, elementData, index, numNew);size += numNew;return numNew != 0;
}

对数组容量进行调整

以上添加数据的方法中都用到了ensureCapacityInternal方法，用于确保内部容量够用

//确保内部容量够用
private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}//计算容量。判断初始化的elementData是不是空的数组,如果是空的话，返回默认容量10与minCapacity=size+1的较大值者。
private static int calculateCapacity(Object[] elementData, int minCapacity) {if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {return Math.max(DEFAULT_CAPACITY, minCapacity);}return minCapacity;
}//确认实际的容量，这个方法就是真正的判断elementData是否够用
private void ensureExplicitCapacity(int minCapacity) {modCount++;//minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。这里有的小伙伴就会模糊minCapacity到底是什么呢，这里解释一下/*** 当我们要 add 进第1个元素到 ArrayList 时，elementData.length 为0 （因为还是一个空的 list），因为执行了 `ensureCapacityInternal()` 方法 ，所以 minCapacity 此时为10。此时，`minCapacity - elementData.length > 0 `成立，所以会进入 `grow(minCapacity)` 方法。* 当add第2个元素时，minCapacity 为2，此时e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，`minCapacity - elementData.length > 0 ` 不成立，所以不会进入 （执行）`grow(minCapacity)` 方法。* 添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。* 直到添加第11个元素，minCapacity(为11)比elementData.length（为10）要大。进入grow方法进行扩容。*/// overflow-conscious codeif (minCapacity - elementData.length > 0)//ArrayList能自动扩展大小的关键方法就在这里了grow(minCapacity);
}//扩容核心方法
private void grow(int minCapacity) {//将扩充前的elementData大小给oldCapacity// overflow-conscious codeint oldCapacity = elementData.length;//新容量newCapacity是1.5倍的旧容量oldCapacityint newCapacity = oldCapacity + (oldCapacity >> 1);//这句话就是适应于elementData就空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10。if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacityif (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//新的容量大小已经确定好了，就copy数组，改变容量大小。// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity);
}//这个就是上面用到的方法，很简单，就是用来赋最大值。
private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflowthrow new OutOfMemoryError();//如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。//Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
}

由此可见ArrayList的扩容机制：首先创建一个空数组：elementData，第一次插入数据的时候，直接扩容到10，如果elementData的长度不够，就直接扩充至1.5倍。如果还是不够，就使用需要的长度作为elementData的的长度

大数据插入问题

大数据情况下的插入会导致频繁的扩容拷贝数据，有两种方法可以解决：

1. 使用 ArrayList(int initialCapacity) 有参构造，在创建的时候就声明一个比较大的容量。但是问题就是需要提前知道数据的量级，以及会一直占有较大的内存
2. 可以在插入前先进行一个扩容，相比1的有点就在于不需要一直占用较大的内存。这个方法就是ensureCapacity（int minCapacity）
   测试：

public class EnsureCapacityTest {public static void main(String[] args) {ArrayList<Object> list = new ArrayList<Object>();final int N = 10000000;long startTime = System.currentTimeMillis();for (int i = 0; i < N; i++) {list.add(i);}long endTime = System.currentTimeMillis();System.out.println("使用ensureCapacity方法前：" + (endTime - startTime));list = new ArrayList<Object>();long startTime1 = System.currentTimeMillis();list.ensureCapacity(N);for (int i = 0; i < N; i++) {list.add(i);}long endTime1 = System.currentTimeMillis();System.out.println("使用ensureCapacity方法后：" + (endTime1 - startTime1));}
}

运行结果：

remove（）

//根据索引删除指定位置的元素
public E remove(int index) {//检查index的合理性rangeCheck(index);//这个作用很多，比如用来检测快速失败的一种标志。modCount++;//通过索引直接找到该元素E oldValue = elementData(index);//计算要移动的位数。int numMoved = size - index - 1;if (numMoved > 0)//移动元素，挨个往前移一位。System.arraycopy(elementData, index+1, elementData, index,numMoved);//将--size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。elementData[--size] = null; // clear to let GC do its work//返回删除的元素。return oldValue;
}//从此列表中删除指定元素的第一个匹配项，如果存在，则删除。通过元素来删除该元素，就依次遍历，
//如果有这个元素，就将该元素的索引传给fastRemobe(index)，使用这个方法来删除该元素，
//fastRemove(index)方法的内部跟remove(index)的实现几乎一样，这里最主要是知道arrayList可以存储null值
public boolean remove(Object o) {if (o == null) {//挨个遍历找到目标for (int index = 0; index < size; index++)if (elementData[index] == null) {//快速删除fastRemove(index);return true;}} else {for (int index = 0; index < size; index++)if (o.equals(elementData[index])) {fastRemove(index);return true;}}return false;
}//内部方法，“快速删除”，就是把重复的代码移到一个方法里
private void fastRemove(int index) {modCount++;int numMoved = size - index - 1;if (numMoved > 0)System.arraycopy(elementData, index+1, elementData, index,numMoved);elementData[--size] = null; // clear to let GC do its work
}//删除或者保留指定集合中的元素
//用于两个方法，一个removeAll()：它只清除指定集合中的元素，retainAll()用来测试两个集合是否有交集。　
private boolean batchRemove(Collection<?> c, boolean complement) {//将原集合，记名为Afinal Object[] elementData = this.elementData;//r用来控制循环，w是记录有多少个交集int r = 0, w = 0;boolean modified = false;try {//遍历 ArrayList 集合for (; r < size; r++)//参数中的集合c一次检测集合A中的元素是否有if (c.contains(elementData[r]) == complement)//有的话，就给集合AelementData[w++] = elementData[r];} finally {//发生了异常，直接把 r 后面的复制到 w 后面if (r != size) {//将剩下的元素都赋值给集合ASystem.arraycopy(elementData, r,elementData, w,size - r);w += size - r;}if (w != size) {//这里有两个用途，在removeAll()时，w一直为0，就直接跟clear一样，全是为null。//retainAll()：没有一个交集返回true，有交集但不全交也返回true，而两个集合相等的时候，//返回false，所以不能根据返回值来确认两个集合是否有交集，而是通过原集合的大小是否发生改变//来判断，如果原集合中还有元素，则代表有交集，而元集合没有元素了，说明两个集合没有交集。// 清除多余的元素，clear to let GC do its workfor (int i = w; i < size; i++)elementData[i] = null;modCount += size - w;size = w;modified = true;}}return modified;
}//保留公共的
public boolean retainAll(Collection<?> c) {Objects.requireNonNull(c);return batchRemove(c, true);
}//将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉
public void clear() {modCount++;//并没有直接使数组指向 null,而是逐个把元素置为空，下次使用时就不用重新 new 了for (int i = 0; i < size; i++)elementData[i] = null;size = 0;
}

总结下来就是，根据索引删除指定位置的元素，需要将指定下标到数组末尾的元素挨个向前移动一个单位，并且将数组的最后一个元素设置为null，这样整个数组不被使用的时候，不会被gc。

get（）

public E get(int index) {// 检验索引是否合法rangeCheck(index);return elementData(index);
}private void rangeCheck(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

get方法就是取出对应索引上的值。在此之前会检查一下索引值是否合法

set（）

//设定指定下标索引的元素值
public E set(int index, E element) {// 检验索引是否合法rangeCheck(index);// 旧值E oldValue = elementData(index);// 赋新值elementData[index] = element;// 返回旧值return oldValue;
}

这个方法没啥好说的……就是设置指定索引上的元素值

indexOf（）

// 从首开始查找数组里面是否存在指定元素
public int indexOf(Object o) {// 查找的元素为空if (o == null) { // 遍历数组，找到第一个为空的元素，返回下标for (int i = 0; i < size; i++) if (elementData[i]==null)return i;} else { // 查找的元素不为空// 遍历数组，找到第一个和指定元素相等的元素，返回下标for (int i = 0; i < size; i++) if (o.equals(elementData[i]))return i;} // 没有找到，返回空return -1;
}//返回列表中指定元素最后一次出现的索引，倒着遍历
public int lastIndexOf(Object o) {if (o == null) {for (int i = size-1; i >= 0; i--)if (elementData[i]==null)return i;} else {for (int i = size-1; i >= 0; i--)if (o.equals(elementData[i]))return i;}return -1;
}

contains（）方法调用的就是indexOf（）方法

toArray（）

/**以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。 */
public Object[] toArray() {//elementData：要复制的数组；size：要复制的长度return Arrays.copyOf(elementData, size);
}public <T> T[] toArray(T[] a) {//如果只是要把一部分转换成数组if (a.length < size)// Make a new array of a's runtime type, but my contents:return (T[]) Arrays.copyOf(elementData, size, a.getClass());//全部元素拷贝到 数组 aSystem.arraycopy(elementData, 0, a, 0, size);if (a.length > size)a[size] = null;return a;
}

System.arraycopy()和 Arrays.copyOf()

上面的源码中很多地方都用了这两个方法
System.arraycopy()： 将指定源数组中的数组从指定位置开始赋值到目标数组的指定位置

// src：源对象
// srcPos：源对象对象的起始位置
// dest：目标对象
// destPost：目标对象的起始位置
// length：从起始位置往后复制的长度。
// 这段的大概意思就是解释这个方法的用法，复制src到dest，复制的位置是从src的srcPost开始，到srcPost+length-1的位置结束，复制到destPost上，从destPost开始到destPost+length-1的位置上
public static void arraycopy(Object src, int srcPos, Object dest, int destPos,int length)

Arrays.copyOf()方法： 选择指定的数组，截断或者填充空值，是副本具体需要指定的长度。

//Arrays的copyOf()方法传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。
//copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值
public static <T> T[] copyOf(T[] original, int newLength) {return (T[]) copyOf(original, newLength, original.getClass());
}/*** @Description 复制指定的数组, 如有必要用 null 截取或填充，以使副本具有指定的长度* 对于所有在原数组和副本中都有效的索引，这两个数组相同索引处将包含相同的值* 对于在副本中有效而在原数组无效的所有索引，副本将填充 null，当且仅当指定长度大于原数组的长度时，这些索引存在* 返回的数组属于 newType 类** @param original 要复制的数组* @param newLength 副本的长度* @param newType 副本的类* * @return T 原数组的副本，截取或用 null 填充以获得指定的长度* @throws NegativeArraySizeException 如果 newLength 为负* @throws NullPointerException 如果 original 为 null* @throws ArrayStoreException 如果从 original 中复制的元素不属于存储在 newType 类数组中的运行时类型*/public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {@SuppressWarnings("unchecked")T[] copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;
}

两者的区别：
copyOf()内部调用了System.arraycopy() 方法

HashMap解析

在jdk8之前，HashMap才用的是数组+链表的形式。即使用链表来处理hash冲突的问题。但是有一个问题就是当同一个hash值的节点存放的数据会越来越多，此时的链表的长度就会越长，对查询的效率降低。在JDK8之后，为了解决hash碰撞过于频繁的问题，HashMap采用数组+链表+红黑树 来实现。当链表长度超出阈值（8）的时候，会将链表转换成红黑树，由此查询的时间复杂度也从O(n)优化成O(lg n)。

特点：

1. 键不可重复，值可以重复
2. 非线程安全
3. 允许key为null，value也可以为null

数据结构

数组的特点是寻址容易，插入和删除困难。
链表的特点是寻址困难，插入和删除容易。
拉链法：就是将数组和链表结合在一起，发挥各自的优势。

1.8之前

1.8之后

当链表长度大于阈值（8）的时候，就会将链表转换为红黑树，减少查询的耗时

继承关系图

HashMap继承抽象类AbstractMap，实现Map接口。除此之外，它还实现了两个标识型接口，这两个接口都没有任何方法，仅作为标识表示实现类具备某项功能。Cloneable表示实现类支持克隆，java.io.Serializable则表示支持序列化

成员变量

//默认初始化Node数组容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大的数组容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//由链表转红黑树的临界值
static final int TREEIFY_THRESHOLD = 8;
//由红黑树转链表的临界值
static final int UNTREEIFY_THRESHOLD = 6;
//桶转化为树形结构的最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap结构修改的次数，结构修改是指更改HashMap中的映射数或以其他方式修改其内部结构(例如，rehash的修改)。该字段用于在Collection-views上快速生成迭代器。
transient int modCount;
//Node数组下一次扩容的临界值，第一次为16*0.75=12（容量*负载因子）
int threshold;
//负载因子
final float loadFactor;
//map中包含的键值对的数量
transient int size;
//表数据，即Node键值对数组，Node是单向链表，它实现了Map.Entry接口，总是2的幂次倍
//Node<K,V>是HashMap的内部类，实现Map.Entry<K,V>接口，HashMap的哈希桶数组中存放的键值对对象就是Node<K,V>。类中维护了一个next指针指向链表中的下一个元素。值得注意的是，当链表中的元素数量超过TREEIFY_THRESHOLD后会HashMap会将链表转换为红黑树，此时该下标的元素将成为TreeNode<K,V>,继承于LinkedHashMap.Entry<K,V>，而LinkedHashMap.Entry<K,V>是Node<K,V>的子类，因此HashMap的底层数组数据类型即为Node<K,V>。
transient Node<K,V>[] table;
//存放具体元素的集,可用于遍历map集合
transient Set<Map.Entry<K,V>> entrySet;

构造方法

//初始化容量以及负载因子
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);
}  //初始化容量
public HashMap(int initialCapacity) {  this(initialCapacity, DEFAULT_LOAD_FACTOR);
}  //默认构造方法
public HashMap() {  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}  //把另一个Map的值映射到当前新的Map中
public HashMap(Map<? extends K, ? extends V> m) {  this.loadFactor = DEFAULT_LOAD_FACTOR;  putMapEntries(m, false);
}  

当初始化HashMap大小时，构造函数并非直接把定义的数值作为HashMap的容量大小，而是把该数值当做参数调用 tableSizeFor() ，然后将返回值作为HashMap的初始大小

tableSizeFor（）：

//HashMap 中 table 角标计算及table.length 始终为2的幂，即 2 ^ n
//返回大于initialCapacity的最小的二次幂数值
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;
}

静态内部类

Node

HashMap将hash，key，value，next都封装到一个静态内部类Node上，实现了Map.Entry<K,V>接口

static class Node<K,V> implements Map.Entry<K,V> {// 哈希值，HashMap根据该值确定记录的位置final int hash;// node的keyfinal K key;// node的valueV 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;}// 返回 node 对应的键public final K getKey()        { return key; }// 返回 node 对应的值public final V getValue()      { return value; }public final String toString() { return key + "=" + value; }public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);}public final V setValue(V newValue) {V oldValue = value;value = newValue;return oldValue;}//作用：判断2个Entry是否相等，必须key和value都相等，才返回truepublic final boolean equals(Object o) {if (o == this)return true;if (o instanceof Map.Entry) {Map.Entry<?,?> e = (Map.Entry<?,?>)o;if (Objects.equals(key, e.getKey()) &&Objects.equals(value, e.getValue()))return true;}return false;}
}

TreeNode

继承与LinkedHashMap.Entery<K，V>，而LinkedHashMap.Entry<K,V>是Node<K,V>的子类，因此HashMap的底层数组数据类型即为Node<K,V>

/*** 红黑树节点 实现类：继承自LinkedHashMap.Entry<K,V>类*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {  // 属性 = 父节点、左子树、右子树、删除辅助节点 + 颜色TreeNode<K,V> parent;  TreeNode<K,V> left;   TreeNode<K,V> right;TreeNode<K,V> prev;   boolean red;   // 构造函数TreeNode(int hash, K key, V val, Node<K,V> next) {  super(hash, key, val, next);  }  // 返回当前节点的根节点  final TreeNode<K,V> root() {  for (TreeNode<K,V> r = this, p;;) {  if ((p = r.parent) == null)  return r;  r = p;  }  }
}

核心方法

hash（）算法

1.8之前HashMap的底层是数组+链表的形式，HashMap通过key的hashCode经过扰动函数处理过后得到的hash值然后通过（n-1）&hash 判断元素存放的位置（n是数组的长度），如果当前位置有元素的话，就判断该元素与要存入的元素的hash值和key是否一样，如果一样则直接覆盖，如果不一样就通过拉链法解决冲突。

上面提到的扰动函数，就是指hash方法，使用hash是为了防止一些实现比较差的hashCode方法，可以有效减少碰撞次数。
hash源码：

// 取key的hashCode值、高位运算、取模运算
// 在JDK1.8的实现中，优化了高位运算的算法，
// 通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，
// 主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，
// 也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

1. 首先获取对象的hashCode（）值，然后将hashCode值右移16位，然后将右移后的值与原来的hashCode值进行异或运算，返回结果（其中h>>>16，在JDK1.8中，优化了高位运算的算法，使用了零扩展，无论正数还是负数，都在高位插入0）。
2. 在putVal源码中，通过(n-1)&hash获取该对象的键在hashmap中的位置。（其中hash的值就是（1）中获得的值）其中n表示的是hash桶数组的长度，并且该长度为2的n次方，这样(n-1)&hash就等价于hash%n。因为&运算的效率高于%运算。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {...if ((p = tab[i = (n - 1) & hash]) == null)//获取位置tab[i] = newNode(hash, key, value, null);...
}

ab即是table，n是map集合的容量大小，hash是上面方法的返回值。因为通常声明map集合时不会指定大小，或者初始化的时候就创建一个容量很大的map对象，所以这个通过容量大小与key值进行hash的算法在开始的时候只会对低位进行计算，虽然容量的2进制高位一开始都是0，但是key的2进制高位通常是有值的，因此先在hash方法中将key的hashCode右移16位在与自身异或，使得高位也可以参与hash，更大程度上减少了碰撞率。

put（）

在put数据的时候，首先计算key的hash值，调用hash方法（此方法实际上是让 key.hashCode()和key.hashCode()>>>16进行异或操作，高16bit补0，一个数和0异或不变，所以hash函数的作用大概就是，高16bit不变，低16bit和高16bit做了一个异或，目的还是减少碰撞）。bucket数组的大小是2的幂

public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}//实现Map.put和相关方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;// 步骤①：tab为空则创建 // table未初始化或者长度为0，进行扩容if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;// 步骤②：计算index，并对null做处理  // (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;// 步骤③：节点key存在，直接覆盖value // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))// 将第一个元素赋值给e，用e来记录e = p;// 步骤④：判断该链为红黑树 // hash值不相等，即key不相等；为红黑树结点// 如果当前元素类型为TreeNode，表示为红黑树，putTreeVal返回待存放的node, e可能为nullelse 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);//判断链表的长度是否达到转化红黑树的临界值，临界值为8if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st//链表结构转树形结构treeifyBin(tab, hash);// 跳出循环break;}// 判断链表中结点的key值与插入的元素的key值是否相等if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))// 相等，跳出循环break;// 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表p = e;}}//判断当前的key已经存在的情况下，再来一个相同的hash值、key值时，返回新来的value这个值if (e != null) { // 记录e的valueV oldValue = e.value;// onlyIfAbsent为false或者旧值为nullif (!onlyIfAbsent || oldValue == null)//用新值替换旧值e.value = value;// 访问后回调afterNodeAccess(e);// 返回旧值return oldValue;}}// 结构性修改++modCount;// 步骤⑥：超过最大容量就扩容 // 实际大小大于阈值则扩容if (++size > threshold)resize();// 插入后回调afterNodeInsertion(evict);return null;
}

①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；

②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；

③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；

④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；

⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；

⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。

resize（）

1. 在JDK1.8中，resize方法在HashMap中的键值大于阈值时，就会调用resize方法进行扩容
2. 每次扩展都是原来的2倍
3. 扩展后的Node对象的位置要么在原位置，要么便宜到原位置两倍的位置

在putVal()中，我们看到在这个函数里面使用到了2次resize()方法，resize()方法表示的在进行第一次初始化时会对其进行扩容，或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发，这也是JDK1.8版本的一个优化的地方，在1.7中，扩容之后需要重新去计算其Hash值，根据Hash值对其进行分发，但在1.8版本中，则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为0，重新进行hash分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上

final Node<K,V>[] resize() {Node<K,V>[] oldTab = table;//oldTab指向hash桶数组int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;int newCap, newThr = 0;if (oldCap > 0) {//如果oldCap不为空的话，就是hash桶数组不为空if (oldCap >= MAXIMUM_CAPACITY) {//如果大于最大容量了，就赋值为整数最大的阀值threshold = Integer.MAX_VALUE;return oldTab;//返回}//如果当前hash桶数组的长度在扩容后仍然小于最大容量 并且oldCap大于默认值16else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)newThr = oldThr << 1; // double threshold 双倍扩容阀值threshold}// 旧的容量为0，但threshold大于零，代表有参构造有cap传入，threshold已经被初始化成最小2的n次幂// 直接将该值赋给新的容量else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;// 无参构造创建的map，给出默认容量和threshold 16, 16*0.75else {               // zero initial threshold signifies using defaultsnewCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}// 新的threshold = 新的cap * 0.75if (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];//新建hash桶数组table = newTab;//将新数组的值复制给旧的hash桶数组// 如果原先的数组没有初始化，那么resize的初始化工作到此结束，否则进入扩容元素重排逻辑，使其均匀的分散if (oldTab != null) {// 遍历新数组的所有桶下标for (int j = 0; j < oldCap; ++j) {Node<K,V> e;if ((e = oldTab[j]) != null) {// 旧数组的桶下标赋给临时变量e，并且解除旧数组中的引用，否则就数组无法被GC回收oldTab[j] = null;// 如果e.next==null，代表桶中就一个元素，不存在链表或者红黑树if (e.next == null)// 用同样的hash映射算法把该元素加入新的数组newTab[e.hash & (newCap - 1)] = e;// 如果e是TreeNode并且e.next!=null，那么处理树中元素的重排else if (e instanceof TreeNode)((TreeNode<K,V>)e).split(this, newTab, j, oldCap);// e是链表的头并且e.next!=null，那么处理链表中元素重排else { // preserve order// loHead,loTail 代表扩容后不用变换下标，见注1Node<K,V> loHead = null, loTail = null;// hiHead,hiTail 代表扩容后变换下标，见注1Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;// 遍历链表do {             next = e.next;if ((e.hash & oldCap) == 0) {if (loTail == null)// 初始化head指向链表当前元素e，e不一定是链表的第一个元素，初始化后loHead// 代表下标保持不变的链表的头元素loHead = e;else                                // loTail.next指向当前eloTail.next = e;// loTail指向当前的元素e// 初始化后，loTail和loHead指向相同的内存，所以当loTail.next指向下一个元素时，// 底层数组中的元素的next引用也相应发生变化，造成lowHead.next.next.....// 跟随loTail同步，使得lowHead可以链接到所有属于该链表的元素。loTail = e;                           }else {if (hiTail == null)// 初始化head指向链表当前元素e, 初始化后hiHead代表下标更改的链表头元素hiHead = e;elsehiTail.next = e;hiTail = e;}} while ((e = next) != null);// 遍历结束, 将tail指向null，并把链表头放入新数组的相应下标，形成新的映射。if (loTail != null) {loTail.next = null;newTab[j] = loHead;}if (hiTail != null) {hiTail.next = null;newTab[j + oldCap] = hiHead;}}}}}return newTab;
}

treeifBin（）

在putVal()方法中，我们能够看到，当链表的长度大于TREEIFY_THRESHOLD这个临界值时，这个时候就会调用treeifyBin()方法，将链表的结构转化为红黑树结构，这也是JDK1.8版本新优化的功能点

在此方法中主要做了：

​ 1、判断桶是否初始化、或者判断桶中的元素个数是否达到MIN_TREEIFY_CAPACITY阈值，没有的话则去进行初始化或者扩容

​ 2、若不符合上述条件，则会对其进行树形化，首先会先去遍历桶中链表的元素，并创建相同的树节点，接着会根据桶的第一个元素而去创建树的头结点，并以此建立联系

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();//开始树形化else if ((e = tab[index = (n - 1) & hash]) != null) {TreeNode<K,V> hd = null, tl = null;//对桶Node中的链表元素进行循环，从链表的头节点开始将链表的头元素改为树的头节点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（）

get方法就是通过getNode来取得元素的

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;// table已经初始化，长度大于0，根据hash寻找table中的项也不为空if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {// 桶中第一项(数组元素)相等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);// 否则，在链表中查找do {if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e;} while ((e = e.next) != null);}}return null;
}

remove（）

/**
* 从HashMap中删除掉指定key对应的键值对，并返回被删除的键值对的值
* 如果返回空，说明key可能不存在，也可能key对应的值就是null
* 如果想确定到底key是否存在可以使用containsKey方法
*/
public V remove(Object key) {Node<K,V> e; // 定义一个节点变量，用来存储要被删除的节点（键值对）return (e = removeNode(hash(key), key, null, false, true)) == null ?null : e.value; // 调用removeNode方法
}

可以发现remove方法底层实际上是调用了removeNode方法来删除键值对节点，并且根据返回的节点对象取得key对应的值，那么我们再来详细分析下removeNode方法的代码

/**
* 方法为final，不可被覆写，子类可以通过实现afterNodeRemoval方法来增加自己的处理逻辑（解析中有描述）
*
* @param hash key的hash值，该值是通过hash(key)获取到的
* @param key 要删除的键值对的key
* @param value 要删除的键值对的value，该值是否作为删除的条件取决于matchValue是否为true
* @param matchValue 如果为true，则当key对应的键值对的值equals(value)为true时才删除；否则不关心value的值
* @param movable 删除后是否移动节点，如果为false，则不移动
* @return 返回被删除的节点对象，如果没有删除任何节点则返回null
*/
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; // 声明节点数组、当前节点、数组长度、索引值/** 如果 节点数组tab不为空、数组长度n大于0、根据hash定位到的节点对象p（该节点为 树的根节点 或 链表的首节点）不为空* 需要从该节点p向下遍历，找到那个和key匹配的节点对象*/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; // 定义要返回的节点对象，声明一个临时节点变量、键变量、值变量// 如果当前节点的键和key相等，那么当前节点就是要删除的节点，赋值给nodeif (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))node = p;/** 到这一步说明首节点没有匹配上，那么检查下是否有next节点* 如果没有next节点，就说明该节点所在位置上没有发生hash碰撞, 就一个节点并且还没匹配上，也就没得删了，最终也就返回null了* 如果存在next节点，就说明该数组位置上发生了hash碰撞，此时可能存在一个链表，也可能是一颗红黑树*/else if ((e = p.next) != null) {// 如果当前节点是TreeNode类型，说明已经是一个红黑树，那么调用getTreeNode方法从树结构中查找满足条件的节点if (p instanceof TreeNode)node = ((TreeNode<K,V>)p).getTreeNode(hash, key);// 如果不是树节点，那么就是一个链表，只需要从头到尾逐个节点比对即可    else {do {// 如果e节点的键是否和key相等，e节点就是要删除的节点，赋值给node变量，调出循环if (e.hash == hash &&((k = e.key) == key ||(key != null && key.equals(k)))) {node = e;break;}// 走到这里，说明e也没有匹配上p = e; // 把当前节点p指向e，这一步是让p存储的永远下一次循环里e的父节点，如果下一次e匹配上了，那么p就是node的父节点} while ((e = e.next) != null); // 如果e存在下一个节点，那么继续去匹配下一个节点。直到匹配到某个节点跳出 或者 遍历完链表所有节点}}/** 如果node不为空，说明根据key匹配到了要删除的节点* 如果不需要对比value值  或者  需要对比value值但是value值也相等* 那么就可以删除该node节点了*/if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {if (node instanceof TreeNode) // 如果该节点是个TreeNode对象，说明此节点存在于红黑树结构中，调用removeTreeNode方法（该方法单独解析）移除该节点((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);else if (node == p) // 如果该节点不是TreeNode对象，node == p 的意思是该node节点就是首节点tab[index] = node.next; // 由于删除的是首节点，那么直接将节点数组对应位置指向到第二个节点即可else // 如果node节点不是首节点，此时p是node的父节点，由于要删除node，所有只需要把p的下一个节点指向到node的下一个节点即可把node从链表中删除了p.next = node.next;++modCount; // HashMap的修改次数递增--size; // HashMap的元素个数递减afterNodeRemoval(node); // 调用afterNodeRemoval方法，该方法HashMap没有任何实现逻辑，目的是为了让子类根据需要自行覆写return node;}}return null;
}

LinkedHashMap解析

LinkedHashMap 继承自 HashMap，在 HashMap 基础上，通过维护一条双向链表，解决了 HashMap 不能随时保持遍历顺序和插入顺序一致的问题。（即LInkedHashMap是有序的）
LinkedHashMap的很多方法都是直接继承自HashMap，仅仅为维护双向链表复写了部分方法。所以下面主要就是讲对双向链表的维护。

原理

LinkedHashMap继承自HashMap，所以底层仍然是基于拉链式的散列结构。

LinkedHashMap在此基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。

每次有新的键值插入的时候，新节点都会接在tail引用指向的节点后面，而tail引用会指向新的节点上。

源码分析

Entry的继承体系

上图可以看到，HashMap的内部类TreeNode不继承他的一个内部类Node，而是继承的Node的子类。LinkedHashMap的内部类Entry继承自HashMap的内部类Node，并新增了两个引用：before和after。这两个引用就是主要用来维护双向链表。同时，TreeNode继承LinkedHashMap内部类Entry后，就具备了和其他Entry一起组成链表的能力。

链表的建立

链表的建立是在插入键值对节点时开始的，初始情况下，让LinkedHashMap的head和tail引用同时指向新节点，链表就算建立起来了。随后不断的又新节点插入，通过将新节点接在tail引用指向的节点后面，即可实现链表的更新
Map类型的集合是通过put（K,V）方法插入键值对，LinkedHashMap本身没有覆写父类的put方法，而是直接使用了父类的实现。但是在HashMap中，put方法插入的是HashMap内部类Node类型的节点，该节点并不具备与LinkedHashMap内部类Entry及其子类型节点组成链表的能力。

// HashMap 中实现
public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}// HashMap 中实现
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;if ((tab = table) == null || (n = tab.length) == 0) {...}// 通过节点 hash 定位节点所在的桶位置，并检测桶中是否包含节点引用if ((p = tab[i = (n - 1) & hash]) == 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) {...}else {// 遍历链表，并统计链表长度for (int binCount = 0; ; ++binCount) {// 未在单链表中找到要插入的节点，将新节点接在单链表的后面if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) {...}break;}// 插入的节点已经存在于单链表中if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null) {...}afterNodeAccess(e);    // 回调方法，后续说明return oldValue;}}++modCount;if (++size > threshold) {...}afterNodeInsertion(evict);    // 回调方法，后续说明return null;
}// HashMap 中实现
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {return new Node<>(hash, key, value, next);
}// LinkedHashMap 中覆写
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {LinkedHashMap.Entry<K,V> p =new LinkedHashMap.Entry<K,V>(hash, key, value, e);// 将 Entry 接在双向链表的尾部linkNodeLast(p);return p;
}// LinkedHashMap 中实现
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {LinkedHashMap.Entry<K,V> last = tail;tail = p;// last 为 null，表明链表还未建立if (last == null)head = p;else {// 将新节点 p 接在链表尾部p.before = last;last.after = p;}
}

把 newNode 方法红色背景标注了出来，这一步比较关键。LinkedHashMap 覆写了该方法。在这个方法中，LinkedHashMap 创建了 Entry，并通过 linkNodeLast 方法将 Entry 接在双向链表的尾部，实现了双向链表的建立。双向链表建立之后，我们就可以按照插入顺序去遍历 LinkedHashMap，大家可以自己写点测试代码验证一下插入顺序。

链表的删除

与插入操作一样，LinkedHashMap 删除操作相关的代码也是直接用父类的实现。在删除节点时，父类的删除逻辑并不会修复 LinkedHashMap 所维护的双向链表，这不是它的职责。那么删除及节点后，被删除的节点该如何从双链表中移除呢？当然，办法还算是有的。上一节最后提到 HashMap 中三个回调方法运行 LinkedHashMap 对一些操作做出响应。所以，在删除及节点后，回调方法 afterNodeRemoval 会被调用。LinkedHashMap 覆写该方法，并在该方法中完成了移除被删除节点的操作。相关源码如下：

// HashMap 中实现
public V remove(Object key) {Node<K,V> e;return (e = removeNode(hash(key), key, null, false, true)) == null ?null : e.value;
}// HashMap 中实现
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) {if (p instanceof TreeNode) {...}else {// 遍历单链表，寻找要删除的节点，并赋值给 node 变量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) {...}// 将要删除的节点从单链表中移除else if (node == p)tab[index] = node.next;elsep.next = node.next;++modCount;--size;afterNodeRemoval(node);    // 调用删除回调方法进行后续操作return node;}}return null;
}// LinkedHashMap 中覆写
void afterNodeRemoval(Node<K,V> e) { // unlinkLinkedHashMap.Entry<K,V> p =(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;// 将 p 节点的前驱后后继引用置空p.before = p.after = null;// b 为 null，表明 p 是头节点if (b == null)head = a;elseb.after = a;// a 为 null，表明 p 是尾节点if (a == null)tail = b;elsea.before = b;
}

上面的代码大致就做了三件事：

1. 根据hash定位到桶的位置
2. 遍历链表或者调用红黑树相关的删除方法
3. 从LinkedHashMap维护的双向链表中移除要删除的节点

根据 hash 定位到该节点属于3号桶，然后在对3号桶保存的单链表进行遍历。找到要删除的节点后，先从单链表中移除该节点。如下：

访问顺序的维护

默认情况下，LinkedHashMap 是按插入顺序维护链表。不过我们可以在初始化 LinkedHashMap，指定 accessOrder 参数为 true，即可让它按访问顺序维护链表。访问顺序的原理上并不复杂，当我们调用get/getOrDefault/replace等方法时，只需要将这些方法访问的节点移动到链表的尾部即可。相应的源码如下：

// LinkedHashMap 中覆写
public V get(Object key) {Node<K,V> e;if ((e = getNode(hash(key), key)) == null)return null;// 如果 accessOrder 为 true，则调用 afterNodeAccess 将被访问节点移动到链表最后if (accessOrder)afterNodeAccess(e);return e.value;
}// LinkedHashMap 中覆写
void afterNodeAccess(Node<K,V> e) { // move node to lastLinkedHashMap.Entry<K,V> last;if (accessOrder && (last = tail) != e) {LinkedHashMap.Entry<K,V> p =(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;p.after = null;// 如果 b 为 null，表明 p 为头节点if (b == null)head = a;elseb.after = a;if (a != null)a.before = b;/** 这里存疑，父条件分支已经确保节点 e 不会是尾节点，* 那么 e.after 必然不会为 null，不知道 else 分支有什么作用*/elselast = b;if (last == null)head = p;else {// 将 p 接在链表的最后p.before = last;last.after = p;}tail = p;++modCount;}
}

假设访问的节点时3

基于 LinkedHashMap 实现缓存

这里通过继承 LinkedHashMap 实现了一个简单的 LRU 策略的缓存。

void afterNodeInsertion(boolean evict) { // possibly remove eldestLinkedHashMap.Entry<K,V> first;// 根据条件判断是否移除最近最少被访问的节点if (evict && (first = head) != null && removeEldestEntry(first)) {K key = first.key;removeNode(hash(key), key, null, false, true);}
}// 移除最近最少被访问条件之一，通过覆盖此方法可实现不同策略的缓存
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {return false;
}

上面的源码的核心逻辑在一般情况下都不会被执行，所以之前并没有进行分析。上面的代码做的事情比较简单，就是通过一些条件，判断是否移除最近最少被访问的节点。看到这里，大家应该知道上面两个方法的用途了。当我们基于 LinkedHashMap 实现缓存时，通过覆写removeEldestEntry方法可以实现自定义策略的 LRU 缓存。比如我们可以根据节点数量判断是否移除最近最少被访问的节点，或者根据节点的存活时间判断是否移除该节点等。本节所实现的缓存是基于判断节点数量是否超限的策略。在构造缓存对象时，传入最大节点数。当插入的节点数超过最大节点数时，移除最近最少被访问的节点。实现代码如下：

public class SimpleCache<K, V> extends LinkedHashMap<K, V> {private static final int MAX_NODE_NUM = 100;private int limit;public SimpleCache() {this(MAX_NODE_NUM);}public SimpleCache(int limit) {super(limit, 0.75f, true);this.limit = limit;}public V save(K key, V val) {return put(key, val);}public V getOne(K key) {return get(key);}public boolean exists(K key) {return containsKey(key);}/*** 判断节点数是否超限* @param eldest* @return 超限返回 true，否则返回 false*/@Overrideprotected boolean removeEldestEntry(Map.Entry<K, V> eldest) {return size() > limit;}
}

测试：

public class SimpleCacheTest {@Testpublic void test() throws Exception {SimpleCache<Integer, Integer> cache = new SimpleCache<>(3);for (int i = 0; i < 10; i++) {cache.save(i, i * i);}System.out.println("插入10个键值对后，缓存内容：");System.out.println(cache + "\n");System.out.println("访问键值为7的节点后，缓存内容：");cache.getOne(7);System.out.println(cache + "\n");System.out.println("插入键值为1的键值对后，缓存内容：");cache.save(1, 1);System.out.println(cache);}
}

输出：
插入10个键值对后，缓存内容：
{7=49, 8=64, 9=81}

访问键值为7的节点后，缓存内容：
{8=64, 9=81, 7=49}

插入键值为1的键值对后，缓存内容：
{9=81, 7=49, 1=1}

在测试代码中，设定缓存大小为3。在向缓存中插入10个键值对后，只有最后3个被保存下来了，其他的都被移除了。然后通过访问键值为7的节点，使得该节点被移到双向链表的最后位置。当我们再次插入一个键值对时，键值为7的节点就不会被移除。

LinkedList

https://thinkwon.blog.csdn.net/article/details/102573923
先把大神的链接放起来，后面在慢慢看

TreeMap

https://thinkwon.blog.csdn.net/article/details/102571883
先把大神的链接放起来，后面在慢慢看

Java集合框架-搬运工相关推荐

1. Java集合框架综述，这篇让你吃透！

   点击上方"方志朋",选择"设为星标" 回复"666"获取新整理的面试文章 作者:平凡希 cnblogs.com/xiaoxi/p/60899 ...

2. 【Java集合框架】ArrayList类方法简明解析（举例说明）

   本文目录 1.API与Java集合框架 2.ArrayList类方法解析 2.1 add() 2.2 addAll() 2.3 clear() 2.4 clone() 2.5 contains() 2 ...

3. Java集合框架的知识总结（1）

   Java集合框架的知识总结(1) 所有集合类都位于java.util包下.集合中只能保存对象(保存对象的引用变量). Java的集合类主要由两个接口派生而出:Collection和Map,Collec ...

4. java集合框架史上最详解（list set 以及map）

   title: Java集合框架史上最详解(list set 以及map) tags: 集合框架 list set map 文章目录 一.集合框架总体架构 1.1 集合框架在被设计时需满足的目标 1.2 ...

5. 【Java集合源码剖析】Java集合框架

   2019独角兽企业重金招聘Python工程师标准>>> Java集合工具包位于Java.util包下,包含了很多常用的数据结构,如数组.链表.栈.队列.集合.哈希表等.学习Java集 ...

6. Java集合框架中Map接口的使用

   在我们常用的Java集合框架接口中,除了前面说过的Collection接口以及他的根接口List接口和Set接口的使用,Map接口也是一个经常使用的接口,和Collection接口不同,Map接口并不 ...

7. java集合框架综述

   一.集合框架图 简化图: 说明:对于以上的框架图有如下几点说明 1.所有集合类都位于java.util包下.Java的集合类主要由两个接口派生而出:Collection和Map,Collection和 ...

8. java集合框架容器 java框架层级 继承图结构 集合框架的抽象类 集合框架主要实现类...

   本文关键词: java集合框架  框架设计理念  容器 继承层级结构 继承图 集合框架中的抽象类  主要的实现类 实现类特性   集合框架分类 集合框架并发包 并发实现类 什么是容器? 由一个或多个确 ...

9. Java集合框架系列教程三：Collection接口

   翻译自:The Collection Interface 一个集合表示一组对象.Collection接口被用来传递对象的集合,具有最强的通用性.例如,默认所有的集合实现都有一个构造器带有一个Colle ...

最新文章

1. 物体掉落速度_俄专家称青海火流星是个“飞船大的物体”，能量堪比万吨炸药爆炸...
2. MySQL 导致 CPU 消耗过大，如何优化
3. MySQL 加锁处理分析 ---非常牛逼
4. HTML5学习路线资料，HTML5前端面试的技术栈
5. 面向组合子程序设计方法 之 新约
6. 1108轮播图和定时器this问题
7. Hi3520D UART2和UART3是如何加载到内核的
8. 智慧城市_城市大脑：加速构建智慧城市
9. JEECG-P3首个开源插件诞生！CMS网站插件 Jeecg-p3-biz-cms1.0版本发布！
10. java 缓存_Java8简单的本地缓存实现
11. python生成条形码和二维码
12. SQL慢查询日志与查询分析器explain
13. 【golang】golang获取客户端ip
14. 怎么理解“付费搜索广告应当与自然搜索结果明显区分”
15. 2021年 - 年终总结
16. linux运行luminati,Luminati使用从入门到精通-Luminati中国
17. 曼尼托巴大学计算机科学硕士,曼尼托巴大学计算机科学本科申请.pdf
18. SEO 一般优化步骤
19. Oracle的ltrim函数
20. RabbitMQ与PHP应用

热门文章

1. 商城项目（四）整合SpringTask实现定时任务
2. SpringBoot 项目将文件图片资源上传到本地静态资源文件夹下（指定文件夹下）
3. Java实现Aligenie天猫精灵OAuth2.0认证授权流程
4. 高性能 Java 持久化的 14 个技巧
5. 【数据可视化】基础知识贴①：激情四溢热力图
6. 关于双数组Trie查询词典构造总结
7. 中投证券L2接口文件说明
8. 认识Json本质 一个较复杂Json串的解析实例
9. Leetcode 957：N 天后的牢房（超详细的解法！！！）
10. 计算机键盘特点,市面上的笔记本键盘优缺点解析，看完秒懂！