共计 6727 个字符，预计需要花费 17 分钟才能阅读完成。
概述
（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<Person> list2 = new ArrayList<>(); 进去的 list2 为空，指向一个 static final Object[]，
当增加元素后，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/684490…
https://zhuanlan.zhihu.com/p/…
https://juejin.cn/post/698127…
正文完
