概述
（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...