09_集合框架
总体架构图
本节内容架构要掌握，总体来看这就是架构图，其中实线是继承部分，虚线是实现部分
为了节省时间和空间，API只是简单的过一遍，更重要的还是在于源码分析
Collection
- 位于
Java.util包下- Collection，单列集合，类似数组一般，不过集合的长度是可以动态扩展的
API
-
增
boolean add(E e);//将元素添加到集合中 boolean addAll(Collection<? extends E> c);//将指定集合中的所有元素添加到集合中 -
删
boolean remove(Object o);//删除指定元素 boolean removeAll(Collection<?> c);//删除所有指定集合中包含的元素 default boolean removeIf(Predicate<? super E> filter);//删除所有满足指定正则的元素 void clear();//清空集合内容 -
改
-
查
int size();//返回集合大小 Iterator<E> iterator();//迭代器，用于遍历 -
断言
boolean isEmpty();//是否为空 boolean contains(Object o);//是否包含指定内容 boolean containsAll(Collection<?> c);//是否包含指定集合中的全部内容 boolean retainAll(Collection<?> c);//集合保留与指定集合相同的内容（保留交集）
boolean equals(Object o);//是否和指定元素相等
- 转换
```java
Object[] toArray();//转为Object数组
<T> T[] toArray(T[] a);//转换为你输入数组类型的数组
Stream<E> stream();//转换为流
//一个新的Collection
Collection<Integer> list = new ArrayList();
//赋值10个
for (int i = 1; i <= 10; i++) {
list.add(i);
}
//假如不为空
if (!list.isEmpty()) {
//转换为Object数组
Object[] objects = list.toArray();
//输出Object数组：12345678910
Arrays.stream(objects).forEach(System.out::print);
//换行
System.out.println();
//转换为指定类型的数组
Integer[] array = list.toArray(new Integer[0]);
//输出：12345678910
Arrays.stream(array).forEach(System.out::print);
}
//换行
System.out.println();
Collection<Integer> list2 = new ArrayList();
//根据指定的集合数据，添加到集合中
list2.addAll(list);
list2.add(11);
//转换为stream流，输出：1234567891011
list2.stream().forEach(System.out::print);
//删除
list.remove(9);
//保留交集
list2.retainAll(list);
System.out.println();
//1234567810
list2.stream().forEach(System.out::print);
//清空
list2.clear();
List
List介绍
- List最大的特点就是有序，可重复
- 有序：指的是进入和输出的顺序是确定的
- 可重复：List中的元素可以有多个重复值
API
-
增
boolean add(E e);//将元素添加到集合中 boolean addAll(Collection<? extends E> c);//将指定集合中的所有元素添加到集合中 boolean addAll(int index, Collection<? extends E> c);//将指定集合从集合的指定位置插入进去 void add(int index, E element);//根据指定的下标添加值到对应的位置中 -
删
boolean remove(Object o);//删除指定元素 boolean removeAll(Collection<?> c);//删除所有指定集合中包含的元素 default boolean removeIf(Predicate<? super E> filter);//删除所有满足指定正则的元素 void clear();//清空集合内容 E remove(int index);//根据指定的下标删除对应的内容 -
改
void replaceAll(UnaryOperator<E> operator);//用函数式接口的返回值替代原来的值 void sort(Comparator<? super E> c);//排序，使用Comparator进行排序 E set(int index, E element);//根据指定的下标将值修改为指定的内容 -
查
int size();//返回集合大小 Iterator<E> iterator();//迭代器，用于遍历 E get(int index);//根据指定下标查询值 int indexOf(Object o);//返回对象在集合中首次出现的位置 int lastIndexOf(Object o);//返回对象在集合中最后一次出现的位置 ListIterator<E> listIterator();//迭代器的升级，不仅可以从前向后遍历，也可以从后向前遍历，还可以自由增删元素 -
断言
boolean isEmpty();//是否为空 boolean contains(Object o);//是否包含指定内容 boolean containsAll(Collection<?> c);//是否包含指定集合中的全部内容 boolean retainAll(Collection<?> c);//集合保留与指定集合相同的内容（保留交集） boolean equals(Object o);//是否和指定元素相等 -
转换
Object[] toArray();//转为Object数组 <T> T[] toArray(T[] a);//转换为你输入数组类型的数组 Stream<E> stream();//转换为流 List<E> subList(int fromIndex, int toIndex);//将指定索引范围（不包含右边）转换为新的List，相当于截取一小部分出来
- 不难看到，我其实是先将Collection中的方法和List中新增的方法使用回车进行了隔离
- 我们其实不难看出来，这些新增加的方法都是一些对索引的操作，或者说是只能由索引带来的操作
Collection<Integer> collection = new ArrayList();
for (int i = 1; i <= 10; i++) {
collection.add(i);
}
List<Integer> list = new ArrayList<>();
//给指定的位置添加内容
list.add(0, 0);
//从集合的指定位置开始插入指定集合的内容
list.addAll(0, collection);
//输出：123456789100
list.stream().forEach(System.out::print);
System.out.println();
//将所有数据替换为所有数据-1
list.replaceAll(integer -> integer - 1);
list.stream().forEach(System.out::print);
System.out.println();
//删除指定位置的元素
list.remove(10);
//转为List的迭代器，可以向前和向后遍历：0123456789
ListIterator<Integer> iterator = list.listIterator();
while (iterator.hasNext()) {
System.out.print(iterator.next());
}
System.out.println();
List<Integer> subList = list.subList(0, 1);
//0
subList.forEach(System.out::print);
ArrayList
特点
- ArrayList底层是使用数组来存储的数据结构，是数组列表
- ArrayList只能装载引用类型，也就是说当我们使用基本类型的时候只能使用它的包装类
- 因为基于数组，所以ArrayList查找快，增删慢
- ArrayList是非线程安全的
深入理解
构造
- 首先我们来看一下它的构造方法
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList() {
//无参构造方法，直接让方法为默认的对象数组，默认的对象集合是一个空的对象数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//指定内容的构造方法
public ArrayList(int initialCapacity) {
//假如容量>0，那么让elementData缓冲数组为新的对象数组，新的对象数组的容量为指定的容量
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//假如容量==0，那么就和无参构造方法一样
this.elementData = EMPTY_ELEMENTDATA;
} else {
//假如容量<0，直接抛异常
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
}
}
//指定集合的构造方法
public ArrayList(Collection<? extends E> c) {
//collection.toArray()，来自Collection集合，具体的作用是将集合转换为数组，这里的缓冲数组就成为了转换的数组
elementData = c.toArray();
//假如长度不为0
if ((size = elementData.length) != 0) {
//假如缓冲数组的类别和Object[]的类别不同，那么直接利用Arrays.copy方法复制过去
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
//假如长度为0，那么还是和无参构造方法一样
this.elementData = EMPTY_ELEMENTDATA;
}
}
我们可以看到，无参构造，集合长度为0的构造，指定长度为0的构造其实在这个时候并没有指定集合的容量大小，只是创建了
- 构造方法的BUG
我们看指定长度的构造方法，当我们指定了长度的构造方法之后，但是size没有改变，size可以说明，就是ArrayList的大小。
ArrayList arrayList = new ArrayList(10);
//0
System.out.println(arrayList.size());
添加
- 接下来我们来看一下增加的方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//假如是空的，那么就返回 DEFAULT_CAPACITY和指定的数据的较大值，DEFAULT_CAPACITY为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
/*
这是一个比较重要的变量，作用是来记录对象的修改次数，当增删改的时候我们一定会看到这个对象
在单线程的条件下，这个对象貌似没有什么用，但是在多线程的情况下可以检测这个变量抛出异常，确保数据安全性
*/
modCount++;
/*
我们刚才已经知道，缓冲数组和我们的集合一样的
那么在这里就是判断传递过来的数值如果比我们的数组长度大，那么就要进行扩容
*/
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
从
calculateCapacity我们可以看到，初始值假如小于10的话，按照10来，假如比10大，那么就按照指定的值
//重点的扩容方法
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//位运算没忘记吧，右移一位就相当于除2，这里也就相当于新的数组容量大小为老的容量的1.5倍，也就是扩容1.5倍数
int newCapacity = oldCapacity + (oldCapacity >> 1);
//假如新的容量值还比指定的容量值要小，那么新的容量值就是指定的容量值，这个情况一般在自己指定大小的时候会用到
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//经历了以上的方法，假如新的容量值竟然要比最大值还要大，将会导致数据溢出，那么直接使用解决策略
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//将旧的数组复制到新的数组中，旧的数组不要了，作为垃圾回收
elementData = Arrays.copyOf(elementData, newCapacity);
}
//ArrayList的溢出解决策略
private static int hugeCapacity(int minCapacity) {
//当值小于0，直接抛出异常
if (minCapacity < 0) throw new OutOfMemoryError();
//假如数据溢出，直接为Integer的最大值，没有溢出就是为设定的最大值，设定的最大值为MAX_ARRAY_SIZE=Integer减8
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
public boolean add(E e) {
//看看是不是要扩容
ensureCapacityInternal(size + 1);
//数组的下一个值增加
elementData[size++] = e;
return true;
}
public void add(int index, E element) {
//超范围直接抛异常
rangeCheckForAdd(index);
//看看是不是要扩容
ensureCapacityInternal(size + 1);
//System.arraycopy(上一个数组,上个数组的起始位置,目标数组,目标数组的起始位置,复制的长度);
System.arraycopy(elementData, index, elementData, index + 1,size - index);
//目标位置
elementData[index] = element;
//size,ArrayList的大小
size++;
}
这就是底层，一般来讲数组的复制最终都会跑到这个
System.arraycopy()下
public boolean addAll(Collection<? extends E> c) {
//转数组
Object[] a = c.toArray();
//得到数组长度
int numNew = a.length;
//判定，size(ArrayList)默认的话是0，但是如果之前加过会改变
ensureCapacityInternal(size + numNew);
//再一次拷贝
System.arraycopy(a, 0, elementData, size, numNew);
//size更改
size += numNew;
//只要加入的集合长度不为0，就是真的
return numNew != 0;
}
//指定位置，添加所有
public boolean addAll(int index, Collection<? extends E> c) {
//超范围直接抛异常
rangeCheckForAdd(index);
//转数组
Object[] a = c.toArray();
//获取长度
int numNew = a.length;
//是否要扩容
ensureCapacityInternal(size + numNew);
//集合长度-目标位置，获得的结果就是长度
int numMoved = size - index;
//假如长度>0
if (numMoved > 0)
//最终要到数组的拷贝,这里是先把原数组进行拷贝，中间现在空出了一部分
System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
//把空出来的部分补上
System.arraycopy(a, 0, elementData, index, numNew);
//ArrayList的长度更改
size += numNew;
//返回结果
return numNew != 0;
}
删除
学习了添加，其实删除也是一样的，底层都是调用了数组的拷贝方法
其他
如果我要使用线程安全的集合应该怎么办
两种方法，一个是使用Vector，一个是使用Collections.synchronizedList把集合包装成一个线程安全的数组容器。
这两种方法都是将所有的方法全都加上一层synchronized
为啥默认起始容量为10
没有什么必须，可能就是当时程序员头脑一排得出来的
删除
删除的时候并不会删除容量，如果要移除多余的容量就要使用方法trimToSize
public void trimToSize() {
//修改次数增加
modCount++;
//假如集合的容量比预计的小，那么缩小（重新拷贝）
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
API使用
属于List的方法
- 添加
| 方法 | 说明 |
|---|---|
boolean add(E) |
添加 |
void add(int,E) |
指定位置添加 |
boolean addAll(Collection<? extends E>) |
添加所有指定集合中的元素 |
boolean addAll(int,Collection<? extends E>) |
指定位置添加所有集合中的元素 |
- 查询
| 方法 | 说明 |
|---|---|
E get(int) |
获得 |
int indexOf(Object) |
查询指定对象在集合中的位置 |
Iterator<E> iterator() |
迭代器 |
ListIterator<E> listIterator() |
获得列表迭代器 |
int lastIndexOf(Object) |
获得指定元素在集合中最后出现的位置 |
int size() |
获取集合的长度 |
列表迭代器和迭代器不同的一点是：列表迭代器可以从后向前遍历，而迭代器只能从前向后遍历
- 删除
| 方法 | 说明 |
|---|---|
void clear() |
清空 |
E remove() |
删除最后一个元素 |
boolean remove(Object o) |
移除指定的元素 |
boolean removeAll(Collection<?> c) |
移除和指定集合产生交集的元素 |
boolean retainAll(Collection<?> c) |
只保留和指定集合产生交集的元素 |
- 修改
| 方法 | 说明 |
|---|---|
E set(int index, E element) |
直接设置指定位置的值 |
- 断言
| 方法 | 说明 |
|---|---|
boolean contains(Object) |
是否包含 |
- 排序
| 方法 | 说明 |
|---|---|
sort(Comparator<? super E> c) |
指定排序规则排序 |
- 转换
| 方法 | 说明 |
|---|---|
List<E> subList(int fromIndex, int toIndex) |
截取指定范围的元素形成一个新的List，不包括右边的范围 |
Object[] toArray() |
转换为Object数组，底层是System.arraycopy |
T[] toArray(T[] a) |
转换为指定类型的数组 |
属于Object的方法
- 转换
| 方法 | 说明 |
|---|---|
Object clone() |
浅克隆 |
属于AbstractList的方法
- 删除
| 方法 | 说明 |
|---|---|
void removeRange(int fromIndex, int toIndex) |
指定范围删除 |
属于Iterable的方法
- 查询
| 方法 | 说明 |
|---|---|
void forEach(Consumer<? super E> action) |
遍历 |
属于Collection的方法
- 删除
| 方法 | 说明 |
|---|---|
boolean removeIf(Predicate<? super E> filter) |
根据正则删除 |
Vector
深入理解
线程安全
Vector基本和ArrayList差不多，基本就是复制版的ArrayList，但是它的方法都是线程安全的
比如给你们看一个添加操作：
public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
ensureCapacityHelper(elementCount + 1);
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
}
扩容
扩容的话和ArrayList还是有些区别的
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//capacityIncrement：扩容增量，有一个构造方法可以指定，假如扩容增量>0就用扩容增量，没有就扩容一倍
int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
扩容增量默认1倍和同步方法的出现导致Vector性能比不上ArrayList，但是在多线程方面是比ArrayList安全的
Stack
class Stack<E> extends Vector<E>
首先看这个源码，Stack继承Vector，说明Vector有的Stack也有
然后看方法
标准的栈结构，入栈，出栈
LinkedList
链表
在讲解LinkedList之前，需要和各位先讲解一下链表的内容
数组
我们先看数组，我们知道，数组我们之前用过，它在内存中需要的是一块连续的存储空间。
因为这个特点，使得数组出现了索引（下标）这种东西，使得它在进行查找的时候特别高效。
那么假如数组的容量超出了还要增加，就要重新创建一个新的数组用来增加
数组的删除有时候不仅仅是单纯的删除，基本类型不可以为null，那么就必须重新创建一个新的数组进行删除
如果是集合必须为引用类型的话，删除没有这么多讲究，但是如果调用
trimToSize也是要进行数组的重新部署
链表
作为数据结构之一的链表，有着明确的分类
假如按照方向分类，分为单向链表和双向链表
假如按照是否循环分类，分为普通链表和循环链表
| 单向链表 | 双向链表 | |
|---|---|---|
| 普通链表 | 单向链表 | 双向链表 |
| 循环链表 | 单向循环链表 | 双向循环链表 |
下面我们就依次来介绍一下
单向链表
作为最为普通的链表，用来介绍一下概念再好不过了
最普通的链表的一块节点的结构是这样的：
这个节点由两部分组成：数据区，地址区。
其中数据区域负责存放数据，而地址区负责存放下一块节点在内存中的地址
因为链表的这种结构，导致和链表和数组不同的特性：
- 它只需要一块地址空间，是否连续是无所谓的。这保证了空间更高效的利用率。
- 因为存放着一块地址空间，所以每一个节点的容量要比数组的每一个节点大一些。
当然了，凡事有利有弊，解决了这个问题，我们就会出现新的问题，我们只需要在不同情况下确保最优选择即可
那么链表的具体结构图是这样的：
为什么有两张图呢，因为这是要分情况的
首先解释一下头结点和首元结点（首结点）和头指针
头指针：指向第一个结点
首元结点：第一个存有有效值的结点
头结点：头结点可以设立可以不设立，设立的时候地址就指向结点1，没有结点1就指向NULL
为什么要设立头结点
- 有了头结点之后，插入和删除操作就和其他的元素一致了
- 一般来说，头结点的名字就是这条链表的名字
不论那张图，都是前一个节点的地址指向后一个节点，最后一个结点指向NULL
双向链表
为了表述方便，我们不使用头结点的结构，并且不再画出指针
它的结构是这样的：
除了刚才单向链表的特性，双向链表还有指向上一个结点地址的特点
单向循环链表
简单来说，就是构成了一个圆环，让最后一个指针不再指向NULL而是指向第一个结点
双向循环链表
我想，这个结构应该也很容易理解，第一个结点前一个是最后一个结点，最后一个结点的下一个是第一个结点
深入理解
首先看一下字段
没错，就这三个
第一个很容易理解，长度
第二个和第三个我们看注释：一个是始终指向头结点，一个始终指向尾结点
Node
我们接下来看看Node
//Node，静态内部类，其中有几个属性
private static class Node<E> {
//值
E item;
//指向下一个节点
Node<E> next;
//指向上一个结点
Node<E> prev;
//构造器：上一个结点，值，下一个节点
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
从这个结点中我们就可以看到，Node，双向链表
为什么要先讲这个呢，因为这个是LinkedList的基础
first和last
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
看源码非常重要的一点就是看注释
如果单看代码你可能会对这两个代码一头雾水，但是如果看注释你就非常清除
first永远指向第一个节点，last永远指向最后一个节点
构造方法
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
有参无参的构造方法是差不多的，有参的是先调用无参的，然后再调用
addAll方法但是我们看到addAll里面又调用了一个新的addAll，老套娃了
检查异常
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
这个主要是用来检查异常的，看到这里没懂不要紧，往后看
获取
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
看到这是不是懂了，用来检查异常的，用到了刚才的检查异常方法
Node<E> node(int index) {
//假如传入的值小于size/2，也就是说假如传入的值小于链表的一半
if (index < (size >> 1)) {
//新建一个节点，让这个节点为开始节点
Node<E> x = first;
//进行循环，从头开始遍历，一直到指定的位置
for (int i = 0; i < index; i++)
//直到遍历到最后
x = x.next;
return x;
} else {
//假如传入的值比size/2大，也就是说传入的值大于链表的一半，从尾部开始遍历
Node<E> x = last;
//从尾部开始向前遍历，一直到指定的值
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
这个方法注释写的很清楚：返回指定元素索引处的(非空)节点
那么我们之前在讲数据结构的时候曾经讲过，链表在查找数据的时候是非常慢的，必须从一端开始查
可能之前在看图的时候没有感觉，但是是不是一看到代码立刻就有感觉了
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
前面的都明白了，这个代码就没什么好讲的了
添加
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
检查异常用的，查看传过来的数值是否>=0并且<=size（链表长度）否则直接抛出异常
- 向后添加
public boolean add(E e) {
linkLast(e);
return true;
}
public void addLast(E e) {
linkLast(e);
}
上面这两个是add和addLast，其实我们可以看到最终调用linkLast，向链表最后添加数据
void linkLast(E e) {
//新建一个节点，让这个节点地址指向最后的节点
final Node<E> l = last;
//新建一个新的节点，这个节点的前一个节点指向刚才的最后的节点，值为e，后一个地址指向null
final Node<E> newNode = new Node<>(l, e, null);
//last节点永远指向最后的节点
last = newNode;
//假如新的节点为null，这也是只有一种情况会出现：刚刚创建节点的时候
if (l == null)
//让first节点为新的节点
first = newNode;
else
//在一般情况下，也就是插入的情况下，刚才的最后的节点的下一个地址指向新的最后的节点
l.next = newNode;
//链表长度+1
size++;
//修改次数+1
modCount++;
}
需要修改次数，因为这样可以保证在并发情况下数据安全
- 向前添加
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
向前添加，套路基本和向后添加差不多，不BB了
- 添加所有
public boolean addAll(int index, Collection<? extends E> c) {
//上面的检查异常用的方法，超过了范围直接抛出越界
checkPositionIndex(index);
//首先将集合转成数组
Object[] a = c.toArray();
//获取集合的长度
int numNew = a.length;
//假如集合没有长度，也就是没有集合内容，直接返回false
if (numNew == 0)
return false;
//定义两个临时节点
Node<E> pred, succ;
/*
假如指定的索引位置等于链表的长度，也就是直接向链表最后添加
注意了，这个非常秒
因为 链表长度 = 最终索引+1，而现在当链表长度=索引位置
而只有一种情况，那就是向链表的最后添加内容，当然了，在初始化添加的时候也是一样，都是向链表最后添加内容
*/
if (index == size) {
succ = null;
//pred = last，在这里想一下之前我画的链表结构，现在就是让临时的这个节点赋值为最后一个节点
pred = last;
} else {
//假如指定的索引长度不等于链表的长度，也就是在中间插入或者在开始插入，反正不是在最后插入
//遍历链表，获取到对应位置的节点值
succ = node(index);
//给这个节点赋值为对应位置节点的前一个节点
pred = succ.prev;
}
//接下来对集合转变为的数组进行遍历，然后进行依次的添加操作
for (Object o : a) {
//这个注解是忽略警告的，后面学到注解再来讲
@SuppressWarnings("unchecked")
//这句简单，无非是弄一个临时变量然后赋值
E e = (E) o;
//定义一个新的节点，这个节点的前一个节点是我们指定的节点的前一个节点，值为刚才遍历出来的值，后一个节点为null
Node<E> newNode = new Node<>(pred, e, null);
/*
假如前一个节点为null，就让first节点（始终指向开始节点的节点）初始化
这行代码只有一种情况会执行，就是初始化LinkedList的时候
*/
if (pred == null)
//初始化first节点
first = newNode;
else
/*
其他，也是一般情况，让我们刚刚创建的节点接上之前的节点
注意，我们是在for循环中，这句和pred = newNode的操作就是一直创建新的节点
然后我们所在的节点和新创建的节点相连接
*/
pred.next = newNode;
//临时节点为我们刚才创建的节点
pred = newNode;
}
//也就是index=size的情况（最后插入），那么假如succ为null,就说明pred是最后一个节点
if (succ == null) {
//last始终指向最后一个节点
last = pred;
} else {
//假如是在中间插入，就让pred的下一个指针指向succ
pred.next = succ;
//然后succ的上一个指针指向pred
succ.prev = pred;
}
//链表长度增加
size += numNew;
//链表的修改次数增加
modCount++;
return true;
}
这就是上面的那个老套娃的addAll，可以看出来，指定好插入的位置然后将元素全部添加，后端的元素直接往后排
还记得我们说过的链表结构么？这就是了
当然，我带领你们看的基本都是常用的，其他的源码你们自己去看，套路很清楚，只要思路清晰就没有问题
API使用
来自双端队列的操作
- 增
| 方法 | 说明 |
|---|---|
addFirst(E e) |
向头添加 |
addLast(E e) |
向尾添加 |
- 删
| 方法 | 说明 |
|---|---|
E removeFirst() |
检索并删除第一个元素 |
E removeLast() |
检索并删除最后一个元素 |
- 查
| 方法 | 说明 |
|---|---|
E getFirst() |
获取链表头元素 |
E getLast() |
获取链表尾元素 |
E peek() |
检索不删除第一个元素 |
关于双端队列的其他方法确实也有，但是我并不想多bb，因为它们调用的要么向前添加，要么向后添加
来自List的操作
- 增
| 方法 | 说明 |
|---|---|
add(E e) |
向尾添加 |
boolean addAll(Collection<? extends E> c) |
添加指定集合中的所有数据 |
boolean addAll(int index, Collection<? extends E> c) |
向链表的指定位置添加指定集合的所有数据，时间复杂度高 |
add(int index, E element) |
向指定位置添加，时间复杂度高 |
int indexOf(Object o) |
查询元素在链表中的位置，时间复杂度高 |
int lastIndexOf(Object o) |
查询元素在链表中最后出现的位置，时间复杂度高 |
- 删
| 方法 | 说明 |
|---|---|
boolean remove(Object o) |
删除指定元素，要遍历，时间复杂度高 |
void clear() |
清空所有 |
- 改
| 方法 | 说明 |
|---|---|
E set(int index, E element) |
设置指定位置的元素，时间复杂度高 |
- 查
| 方法 | 说明 |
|---|---|
int size() |
获取链表长度 |
E get(int index) |
获取指定位置的元素，时间复杂度高 |
- 断言
| 方法 | 说明 |
|---|---|
boolean contains(Object o) |
链表中是否包含指定元素 |
- 转换
| 方法 | 说明 |
|---|---|
Object[] toArray() |
转为数组 |
T[] toArray(T[] a) |
转为指定类型的数组 |
来自Object的方法
- 转换
| 方法 | 说明 |
|---|---|
Object clone() |
浅克隆 |
CopyOnWriteArrayList
在这里请允许我卖个关子，因为这个东西要到JUC里面去讲
Map
Map介绍
前言
在这里我们可以看到顺序，没有先讲Set，而是直接讲了Map
这个顺序是有理由的，往后看就可以了
Map结构
如果说Collection家族的数据结构还可以让你让你想象一下，那么Map的结构肯定也可以让你脑补一下
简单来讲，Map家族的结构是key-value形式的，这个意思是说一个键对应一个值
这个和Collection不同，Collection是一种值排成了一串，而Map是一一对应。
对于Map，或者你也可以理解为身份证号和名字的对应关系
key是不可以重复的，但是value是可以重复的。这就和身份证号和名字一样
key只能映射到一个值，就像身份证号一样，一次只能映射到一个人身上。
总结起来就是Map的特点
- Map是键值对对象，一个键对应一个值
- 键不可以重复，但是值可以重复
- Map的数据结构与键有关，和值无关
hash，hashcode
哈希，也叫散列表，其实这个哈希在之前的博客中已经讲过
JDK7的HashMap
简单介绍
首先有一个大体的印象，带着这个印象去看源码会比较好理解：
1、JDK7中的HashMap的结构是使用数组+链表进行实现的
2、当我们使用put操作向HashMap中添加数据的时候，我们添加的是key-value的形式，但其实会将这个key-value封装为一个Entry对象，所以数组中存储的其实是一个引用地址，而不是真正的值
3、HashMap的put操作根据key来取，首先根据key取hashcode，得到hashcode的值，然后将值进行缩减，得到一个小的值，算出要存放的数组的下标，如果数组下标处有元素了，那就使用头插法形成一个链表
而且使用头插法的时候，插入的效率会比较快
4、get操作和put方式有些类似，首先根据key获取hashcode（输入值固定，hashcode固定），然后进行缩减，然后就获得了数组的下标，如果有链表，就进行遍历
当我们回顾ArrayList的添加操作的话，我们可以知道直接让数组的下一个位置增加了，也就是说不论扩容，单纯的增加元素是没什么技术含量的，但是这样的插入方式无疑是最快的。并且ArrayList的取值也不慢，因为直接通过下标来取值。
但是HashMap不可以这样增加数据，我们想象一下，假如HashMap像ArrayList一样，增加数据只是简单地放到下一位，这样插入的效率确实会高很多，但是查询的效率会非常低，因为HashMap的取值是使用key来取而不是下标。
深入理解
- 首先看一下HashMap中比较重要的的属性
//默认数组的初始化容量，16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//HashMap的存放最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//一个空的Entry数组
static final Entry<?,?>[] EMPTY_TABLE = {};
//表示HashMap中的数组，一开始就是一个空数组，是Entry类型
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//HashMap中所有元素的多少
transient int size;
//阈值，根据加载因子算出
int threshold;
//负载因子，这个是到时候用到的负载因子
final float loadFactor;
//HashMap的改变次数，多线程下可以保证安全性
transient int modCount;
//哈希种子
transient int hashSeed = 0;
- 构造方法
public HashMap() {
//传递的参数为：初始化容量大小16，默认负载因子0.75
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity) {
//调用下面的构造方法，传递的参数为：初始化容量大小，默认负载因子0.75
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 不论哪个HashMap，最终都要调用这个构造方法
*
* @param initialCapacity 初始化的容量大小
* @param loadFactor 负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
//初始化容量<0，直接抛异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//初始化容量大与最大容量，还是最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//负载因子小于0或者负载因子根部不是个数字，也抛异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//负载因子初始化
this.loadFactor = loadFactor;
//阈值初始化为容量大小
threshold = initialCapacity;
//init在HashMap中是空的，但是在LinkedHashMap中是有用的
init();
}
- put方法
/**
* 对HashMap中存值
*
* @param key 键
* @param value 值
* @return null
*/
public V put(K key, V value) {
//假如HashMap中的数组是一个空的数组，说明HashMap还是空的
if (table == EMPTY_TABLE) {
//初始化，传递了阈值进去
inflateTable(threshold);
}
//假如key是null，没有抛异常，这说明HashMap中，key是可以为null的
if (key == null)
return putForNullKey(value);
//返回一个hash值
int hash = hash(key);
/*
拿hash值和数组的下标进行与运算，得到要插入进去的数组下标
这里需要说明一下：当length是一个2的幂次方数时，hash & (length-1)其实就是 hash%length
所以数组的长度必须为2的幂次方
顺便说一下，indexFor里面其实就是返回hash & (length-1)，下面就不贴函数了
*/
int i = indexFor(hash, table.length);
/*
循环，从table[i]开始，也就是从新元素要插入数组的索引位置开始
只要要插入数组的索引位置不为空，也就是说只要有这个地方有元素就开始死循环
只要循环一次，链表节点+1
总之，这个for循环就是遍历数组对应位置中的链表用的
*/
for (HashMap.Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
/*
元素的输入相同，hash值就会相同，但是hash值相同，输入不一定相同
但是e.hash==hash，e.key==key，key.equals(k)
这三者加起来就是明明白白地确认输入是相同的
也就是确认这个节点里key是不是一样
*/
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
//新的值替换掉老的值
V oldValue = e.value;
e.value = value;
//这是个空的，LinkedHashMao中用
e.recordAccess(this);
//返回老的值
return oldValue;
}
//也就是说这个for循环其实就干了一件事：替换掉老的值并返回
}
//HashMap的修改数+1，这里需要注意，假如在上面替换掉了老的值，在上面就已经将数据返回了，这里的修改数是不增加的
modCount++;
//那么我们说，假如这个值以前没有增加过，那么就在这里增加一个新的元素
addEntry(hash, key, value, i);
//新的元素，返回的肯定就是null了
return null;
}
总结：put方法做了这么几件事情：
1、判断key是否为null，如果为null那么就将这个值放到固定位置上
2、假如不为null，那么使用key获取到hash值并且使用与操作将值缩减为数组大小范围内的值
3、使用for循环来遍历数组下标中的链表，如果有对应的key，那么新的值覆盖老的值，然后返回老的值。假如没有对应的key，那么modCount+1，并且在链表上插入一个新的Entry
/**
* 将传过来的key进行一个hash运算
*
* @param k HashMap中，传过来的key
* @return 进行完hash运算后的结果
*/
final int hash(Object k) {
//我们的hashSeed，哈希种子默认为0
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
/*
这里使用哈希种子和键的哈希值进行一个异或运算
我们知道，异或运算是相同为0，不同为1
所以在这里进行异或运算的时候h也会进行变化
*/
h ^= k.hashCode();
//然后又进行向右位移，然后进行异或，得到后来的结果
h ^= (h >>> 20) ^ (h >>> 12);
//最后返回的时候继续移动，然后进行异或运算
return h ^ (h >>> 7) ^ (h >>> 4);
}
所以，这里的结果其实不是我们直接调用了hashcode()返回的结果，而是进行运算得到的结果
/**
* HashMap初始化
*
* @param toSize 传递了阈值进来
*/
private void inflateTable(int toSize) {
//求2的幂次方，数组的容量必须是2的幂次方，这个原因在前面讲了
int capacity = roundUpToPowerOf2(toSize);
/*
阈值为
1、容量*负载因子
2、HashMap存放的最大容量+1。
这两个取一个小值，当然一般情况是容量*负载因子
*/
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//对HashMap的数组进行了初始化
table = new HashMap.Entry[capacity];
initHashSeedAsNeeded(capacity);
}
/**
* 寻找一个最近的2的幂次方数，将其转换
*
* @param number 传进来的数字
* @return 2的幂次方数
*/
private static int roundUpToPowerOf2(int number) {
/*
1 0000 0001
2 0000 0010
4 0000 0100
8 0000 1000
16 0001 0000
....
所以规律是：只有bit位置上一个为1的才是2的幂次方数
那么在这里，首先判断是不是大于最大容量
- 大于最大容量，那么就返回最大容量
- 没有大于最大容量，判断传进来的数字是否>1
- 不大于1，返回1
- 大于1，那么进行Integer.highestOneBit((number - 1) << 1)
(number - 1) << 1，这个很有讲究
左移一位，再去调用highestOneBit，因为这个方法的作用是返回小于等于给定数字的最接近的2的幂次方数
而-1就更好了，因为我们以16为例，16-1=15，15进行翻倍是30，然后去调用highestOneBit，得到的结果还是16
假如是highestOneBit(number<<1)，16翻倍是32，32然后去调用highestOneBit，得到的结果是32，整整大了一倍
*/
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
/**
* 传进来的数字转换为小于等于我们传进来的数的2的幂次方数
*
* @param i 数字
* @return 小于i的2的幂次方数
*/
public static int highestOneBit(int i) {
/*
比方说我们传了个17进来：0001 0001
0001 0001
>>1 0000 1000
| 0001 1001
>>2 0000 1100
| 0001 1101
>>4 0000 0111
| 0001 1111
>>8 0000 0000
| 0001 1111
....
| 0001 1111
在最后，return的时候，再次右移一位，也就是说
i - (i >>> i)
0001 1111 - 0000 1111 = 0001 0000 = 16
从上面的代码我们可以得到一个规律，我们所在的最高位有一个1，然后我们右移，让我们数字的最高位后面的所有数字都改成1
然后最后一减，最后只剩下了最高位的那个1，这就是2的幂次方，只不过是小于等于我们传进来的数
*/
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
因为int类型是4字节，32个bit位，1+2+4+8+16=32，这样就可以覆盖全部的int
/**
* 假如key是null，同样也能push进去
* @param value 值
* @return
*/
private V putForNullKey(V value) {
/*
hashmap要push一个键为null的Entry，直接就放在了数组第一个位置上
这里对链表进行遍历，替换掉旧数据并返回
*/
for (HashMap.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;
}
}
//修改次数+1
modCount++;
//假如没有null的键，直接就添加一个新的元素
addEntry(0, null, value, 0);
return null;
}
这里就是具体的，假如传入的key-value中，key为null的解决方式
/**
* 增加元素
*
* @param hash hash值
* @param key 键
* @param value 值
* @param bucketIndex 要插入的数组下标位置
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
//判断HashMap的总元素是不是大于阈值，以及这个数组的位置上不为空的时候，重新进行扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
//进行扩容，我们看到扩容的时候也是扩容为了2*table.length，扩容二倍的原因我们之前已经讲过了，数组容量必须为2的幂次方
resize(2 * table.length);
//重新hash，如果这个键为null，那么就是0
hash = (null != key) ? hash(key) : 0;
//数组索引重新进行运算
bucketIndex = indexFor(hash, table.length);
}
//进行元素的添加
createEntry(hash, key, value, bucketIndex);
}
这里需要注意一点，我们之前都以为只要HashMap的数值长度高于阈值就要扩容，其实不是，其实还有一个条件，就是当前数组的位置不为空的时候才会进行扩容操作
而且我们要注意，size的意思是hashmap中存入了多少数据
/**
* 扩容操作
*
* @param newCapacity 新的数组容量
*/
void resize(int newCapacity) {
//获得老的数组，和老的数组的长度
HashMap.Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//假如老的数组最大长度为HashMap所允许的最大长度，不进行扩容
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//扩容时，定义一个新的数组，新数组的大小为原来数组的二倍
HashMap.Entry[] newTable = new HashMap.Entry[newCapacity];
//进行数据的转移，将原来数组的数据转移到新数组中
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//重新对阈值进行计算
threshold = (int) Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
/**
* 将原数组的所有值都放到新数组中
*
* @param newTable 新数组
* @param rehash 是否要重新进行hash计算，我们大部分情况下是false
*/
void transfer(HashMap.Entry[] newTable, boolean rehash) {
//获得新的容量大小啊
int newCapacity = newTable.length;
//进行数据的转移，我们可以看到一个for嵌套一个while，是双重循环
for (HashMap.Entry<K, V> e : table) {
while (null != e) {
HashMap.Entry<K, V> next = e.next;
//这一步十分重要，是否要进行rehash，我们一般传过来的都是false
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//假如没有进行rehash，那么得到的值只有两个结果：
//1、元素下标还是原来的 2、元素下标改变为原来的下标+原来的数组长度
int i = indexFor(e.hash, newCapacity);
/*
来看一下这个元素节点，JDK7中的HashMap扩容存在很大的问题
首先我们要明确，扩容的目的不仅是为了增大数组的容量，还要让链表的长度变短
简单来说是将一个长长的链表转换为一些短链表，所以它必须对链表进行循环，使用重新添加的方式重新将链表的结点一个一个拿出来，然后存到新数组的下标位置
但是因为头插法的原因，这样就会造成一些问题：
1、扩容之前和扩容之后链表的顺序将会反转，比如原来是1->2->3，扩容后是3->2->1
2、多线程下会造成链表循环指向的问题
所以其实根源是在于链表的头插法，将链表的顺序进行了改变
*/
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
下面的一切结论都是建立在没有进行rehash的情况下： 假如没有进行rehash，那么得到的结果有两种可能： 1、得到的数组下标是原数组的下标 2、得到的数组下表是原数组下标 + 原数组长度 这一段你们可能很难理解，举个例子就行了，比如说： 1)假如我们的hash值为0101 0101 1. 扩容前： 我们要进行indexFor，得到数组的下标 根据key得到的hash值为 0101 0101 数组的长度length为16 进行indexFor运算：0101 0101 & (16-1) 得到结果：0000 0101：数组下标为5 2.扩容后 我们要进行indexFor，得到数组的下标 根据key得到的hash值为 0101 0101 数组的长度length为32 进行indexFor运算：0101 0101 & (32-1) 得到结果：0001 0101：数组下标为5+16，也就是原数组索引+原数组长度 2)假如我们的hash值为0100 0101 1. 扩容前： 我们要进行indexFor，得到数组的下标 根据key得到的hash值为 0100 0101 数组的长度length为16 进行indexFor运算：0101 0101 & (16-1) 得到结果：0000 0101：数组下标为5 2.扩容后 我们要进行indexFor，得到数组的下标 根据key得到的hash值为 0100 0101 数组的长度length为32 进行indexFor运算：0101 0101 & (32-1) 得到结果：0000 0101：数组下标为5，也就是和原数组的下标相同所以其实我们只需要看最高位是0还是1，假如我们扩容的高位为0，那么就是原来的，假如为1，那就是原来下标+原数组长度
/**
* 添加元素
*
* @param hash hash值
* @param key 键
* @param value 值
* @param bucketIndex 要添加的数组下标
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
//下面即将使用头插法
//首先获取到这个数组中存放的地址值，也就是链表的头结点
HashMap.Entry<K, V> e = table[bucketIndex];
/*
数组存放的地址值为一个新的HashMap的Entry，也就是说链表的头结点变为了这个新的节点
同时这里注意，最后传递了原来的头结点，这个最后的e就是节点的next
头插法完成
*/
table[bucketIndex] = new HashMap.Entry<>(hash, key, value, e);
//HashMap总长度+1
size++;
}
可以看到，头插法的效率就是如此之高，如果使用尾插法，那么首先要对这个链表进行一层遍历，然后才能在最后插入数据
但是在HashMap中，只要使用put方法，那么就要对这整个链表进行遍历，那么遍历完成之后肯定会得到尾部的节点，从这一点来看，在HashMap中头插法和尾插法好像没有什么太大的区别
- put总要遍历一遍链表
JDK8的HashMap
红黑树
红黑树是一颗平衡树，它在算法导论中是这样定义的：
1、每一个节点是红色的或者是黑色的
2、根节点（第一个节点）必须是黑的
3、每一个叶子节点必须是黑色的，你可以理解为指向null的都是黑色的
4、不能有两个连续的红节点（红色节点的子节点必须是黑色的）
5、黑节点平衡（从任何一个节点到达它的子孙节点中的任何一个叶子节点中，黑节点拥有相同的数量）
比如在上面这张图中，比如30到叶子节点(NULL)中，都是两个黑色节点
红黑树插入新节点改如何判断是红色还是黑色
第五条是最难遵守的，所以我们默认插入的就是红色的节点，然后判断是否遵守其他的四个定义。
因为我们插入红色节点的时候，没有破坏黑节点平衡这个条件。假如我们插入了黑色的节点，很容易就会破坏黑节点平衡这个条件。
红黑树的左旋和右旋
平衡树想要平衡，需要旋转。红黑树就是一颗典型的平衡树，所以它也是需要旋转的。
举个例子：
现在有一颗红黑树（没有画叶子节点）：
现在我们要向树中添加一个数字：60
根据我们的计算，最后的结果应当是：30指向45，45下面的左节点位40，右节点为60
我们对比两张图片可以开电脑，原来的30是指向了40，但是现在指向了45，这种情况就是红黑树的左旋。
右旋也是一样的，就类似这种结果。
那么现在来总结一下，在红黑树插入新节点的过程中，是如何进行改变的：``
1、假如父节点是黑色的，不用进行调整
2、假如父节点是红色的
- 假如叔叔为空，旋转+变色
- 叔叔为黑色，旋转+变色
- 叔叔为红色，父节点+叔叔节点变为黑色，祖父节点变为红色（进行递归，直到整个红黑树满足规则即可结束）
HashMap的理解
public V put(K key, V value) {
/*
四个参数
第一个hash值
第四个参数表示如果该key存在值如果为null的话，则插入新的value
最后一个参数，在hashMap中没有用，可以不用管，使用默认的即可
*/
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
//tab为哈希数组，p为该哈希桶（数组桶）的首节点，n为hashMap的长度，i为计算出的数组下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//获取长度并进行扩容，使用的是懒加载，table一开始是没有加载的，等put后才开始加载
if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;
/*
如果计算出的该哈希桶的位置没有值，则把新插入的key-value放到此处
此处就算没有插入成功，也就是发生哈希冲突时也会把哈希桶的首节点赋予p
*/
if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);
//发生哈希冲突的几种情况
else {
// e 临时节点的作用， k 存放该当前节点的key
Node<K,V> e; K k;
//第一种，插入的key-value的hash值，key都与当前节点的相等，e = p，则表示为首节点
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k)))) e = p;
//第二种，hash值不等于首节点，判断该p是否属于红黑树的节点
else if (p instanceof TreeNode)
/*
为红黑树的节点，则在红黑树中进行添加
如果该节点已经存在，则返回该节点（不为null）
该值很重要，用来判断put操作是否成功，如果添加成功返回null
*/
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种，hash值不等于首节点，不为红黑树的节点，则为链表的节点
else {
//遍历该链表
for (int binCount = 0; ; ++binCount) {
//如果找到尾部，则表明添加的key-value没有重复，在尾部进行添加
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
/*
判断是否要转换为红黑树结构（或者进行扩容），这里的TREEIFY_THRESHOLD为8
但是注意binCount是从0开始增加的，这就代表着加到7的时候就已经是8条数据了
*/
if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash); break;
}
//如果链表中有重复的key，e则为当前重复的节点，结束循环
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))) break;
p = e;
}
}
//有重复的key，则用待插入值进行覆盖，返回旧值。
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//到了此步骤，则表明待插入的key-value是没有key的重复，因为插入成功e节点的值为null
//修改次数+1
++modCount;
//实际长度+1，判断是否大于临界值，大于则扩容
if (++size > threshold) resize();
afterNodeInsertion(evict);
//添加成功
return null;
}
/*
我们在上面说，当数组中的链表大于8的时候，就要进行判断是否要进行扩容，或者是转换为红黑树
*/
final void treeifyBin(HashMap.Node<K,V>[] tab, int hash) {
int n, index; HashMap.Node<K,V> e;
// 如果Map为空或者当前存入数据n（可以理解为map的size()）的数量小于64便进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize();
// 如果size()大于64则将正在存入的该值所在链表转化成红黑树
else if ((e = tab[index = (n - 1) & hash]) != null) {
HashMap.TreeNode<K,V> hd = null, tl = null;
do {
HashMap.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);
}
}
数组扩容只需要满足以下两个条件之一即可：
1、HashMap的容量超过了负载因子的限制容量（默认为0.75）时，扩容。比如数组有16个，填满了12个就开始扩容
2、某个数组桶中，链表的长度大于8并且HashMap数组长度小于64，进行扩容
数组中的链表转换为红黑树的条件：当前数组桶中的链表长度大于等于8并且数组长度大于等于64，开始转换为红黑树。
假如红黑树的节点小于6，那么转换回链表
©
本作品原创
