ArrayList-源码分析
概述
（1）ArrayList 是一种变长的集合类，基于定长数组实现。
（2）ArrayList 允许空值和重复元素，添加元素时，会扩容机制生成一个更大的数组。
（3）可以保证在 O(1) 复杂度下完成随机查找操作。
（4）ArrayList 是非线程安全类。
为追求效率，ArrayList没有实现同步（synchronized），如果需要多个线程并发访问，用户可以手动同步，也可使用Vector替代。
类的属性
/**
* 默认初始容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 共享的空数组实例，用于空实例
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
*ArrayList 实际数据存储的一个数组
*存储ArrayList的元素的数组缓冲区。 ArrayList的容量是此数组缓冲区的长度。
*添加第一个元素时，任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList都将扩展为DEFAULT_CAPACITY。
Object[]数组，也就是说该数组可以放任何对象（所有对象都继承自父类Object）
*/
transient Object[] elementData;
/**
* 共享的空数组实例，用于默认大小的空实例
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* elementData 的大小，size是逻辑长度，并不是数组长度。
*/
private int size;
//很有意思，下面介绍
protected transient int modCount = 0;
static修饰的变量，常驻于方法区，我们不需要new，JVM会提前给我们初始化好，这个特性在实际开发过程中，经常拿来做缓存。
ArrayList new的时候考虑了缓存，为了避免我们反复的创建无用数组，所有新new出来的ArrayList底层数组都指向缓存在方法区里的Object[]数组。
构造方法
//参数为初始化容量
public ArrayList(int initialCapacity) {
//判断容量的合法性
if (initialCapacity > 0) {
//elementData才是实际存放元素的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//如果传递的长度为0，就是直接使用自己已经定义的成员变量(一个空数组)
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//无参构造，使用默认的size为10的空数组，在构造方法中没有对数组长度进行设置，会在后续调用add方法的时候进行扩容
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//将一个参数为Collection的集合转变为ArrayList（实际上就是将集合中的元素换为了数组的形式）。
//传入的集合为null会抛出空指针异常（调用c.toArray()方法的时候）
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
//c.toArray()可能不会正确地返回一个 Object[]数组，那么使用Arrays.copyOf()方法
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
//如果集合转换为数组之后数组长度为0，就直接使用自己的空成员变量初始化elementData
this.elementData = EMPTY_ELEMENTDATA;
}
}
图解析：例如 List
当添加元素后，elementData 指向 elementData[10]（DEFAULT_CAPACITY = 10），size 是逻辑长度，加一。
add，grow以及工具类底层分析
public boolean add(E e) {
//因为要添加元素，所以添加之后可能导致容量不够，所以需要在添加之前进行判断（扩容）
ensureCapacityInternal(size + 1);
// Increments modCount!!待会会介绍到fast-fail!!
//但是这个扩容的方法里面调用了。add（）方法就不用调用了。其实是调用过了的,modCount 已经加了1。
//值e放到相应的elementData[]下标的数组里面
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//如果底层数组就是默认的缓存数组，取两个参数的大的一个值继续往下调用
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//这里就是判断elementData数组是不是为空数组
//（使用的无参构造的时候，elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA）
//如果是，那么比较size+1(第一次调用add的时候size+1=1)和DEFAULT_CAPACITY，
//那么显然容量为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
//记录修改次数
modCount++;
//溢出
//如果传过来的值大于底层数组的长度，继续grow方法。
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// oldCapacity为旧数组的容量
int oldCapacity = elementData.length;
// newCapacity为新数组的容量（oldCap+oldCap/2:即更新为旧容量的1.5倍）
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 检查新容量的大小是否小于最小需要容量，如果小于那旧将最小容量最为数组的新容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新容量大于MAX_ARRAY_SIZE，使用hugeCapacity比较二者
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
// 将原数组中的元素拷贝
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
@Native public static final int MAX_VALUE = 0x7fffffff;
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//对minCapacity和MAX_ARRAY_SIZE进行比较
//若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
//若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
//工具类
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;
}
//System.arraycopy()方法,native方法，所以直接只用这个方法会获得很高的性能
//这个也是具体的扩容的具体底层实现
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
//src:源数组
//srcPos:从源数组的srcPos位置处开始移动
//dest:目标数组
//desPos:源数组的srcPos位置处开始移动的元素，这些元素从目标数组的desPos处开始填充
//length:移动源数组的长度
扩容：newCapacity为新数组的容量（oldCap+oldCap/2:即更新为旧容量的1.5倍）
remove方法分析
1、remove(int index) 按照下标删除
public E remove(int index) {
rangeCheck(index); //校验下标是否合法（如果index>size，旧抛出IndexOutOfBoundsException异常）
modCount++;//修改list结构，就需要更新这个值
E oldValue = elementData(index); //直接在数组中查找这个值
int numMoved = size - index - 1;//这里计算所需要移动的数目
//如果这个值大于0 说明后续有元素需要左移(size=index+1)
//如果是0说明被移除的对象就是最后一位元素(不需要移动别的元素)
if (numMoved > 0)
//索引index只有的所有元素左移一位 覆盖掉index位置上的元素
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//移动之后，原数组中size位置null
elementData[--size] = null; // clear to let GC do its work
//返回旧值
return oldValue;
}
2、remove(Object o) 按照元素删除，会删除和参数匹配的第一个元素
public boolean remove(Object o) {
//如果元素是null 遍历数组移除第一个null
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//遍历找到第一个null元素的下标 调用下标移除元素的方法
fastRemove(index);
return true;
}
} else {
//找到元素对应的下标 调用下标移除元素的方法
for (int index = 0; index < size; index++)
//要用equals
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
}
fail-fast
在系统设计中，快速失效系统一种可以立即报告任何可能表明故障的情况的系统。
快速失效系统通常设计用于停止正常操作，而不是试图继续可能存在缺陷的过程。
这种设计通常会在操作中的多个点检查系统的状态，因此可以及早检测到任何故障。
快速失败模块的职责是检测错误，然后让系统的下一个最高级别处理错误。
在Java集合类中很多地方都用到了该机制进行设计，一旦使用不当，触发fail-fast机制设计的代码，就会发生非预期情况。
我们通常说的Java中的fail-fast机制，默认指的是Java集合的一种错误检测机制。
当多个线程对部分集合进行结构上的改变的操作时，有可能会触发该机制时，之后就会抛出并发修改异常ConcurrentModificationException.
然如果不在多线程环境下，如果在foreach遍历的时候使用add/remove方法，也可能会抛出该异常。
public boolean add(E e) {
ensureCapacityInternal(size + 1);
// Increments modCount!!待会会介绍到fast-fail!!
//但是这个扩容的方法里面调用了。add（）方法就不用调用了。其实是调用过了的,modCount 已经加了1。
elementData[size++] = e;
return true;
}
Arraylist与Vector的区别
用得比较少了。
public class Vector<E>
extends AbstractList<E>
//实现List接口
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//底层数组实现
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
Vector源码分析
//声明了同步得关键字
public synchronized boolean add(E e) {
modCount++;
//检查是否扩容
ensureCapacityHelper(elementCount + 1);
//赋值
elementData[elementCount++] = e;
return true;
}
无一例外，只要是关键性的操作，方法前面都加了synchronized关键字，来保证线程的安全性。
不同点：扩容后是旧容量的俩倍。
参考链接
https://juejin.cn/post/6844903904346374158
