参考：https://blog.csdn.net/weixin_38405253/article/details/100170568
https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html
https://www.cnblogs.com/yonyong/p/9323546.html
https://www.cnblogs.com/mabingxue/p/9176324.html
看源码一定要有耐心，第一次看可能看不懂，后面再看可能还是看不懂，但是别放弃治疗，我还是要看。不过这ArrayList我还是看的懂一些的。我看了很久发现我的idea里面了源码和我查到的很多分析的源码都不一样，找了很久发现，原来大家都是jdk1.8版本的，我的是jdk1.9版本的，里面有一些不一样，发现大家都推荐jkd1.8，普遍推荐吧，应该。
https://segmentfault.com/a/1190000019326016?utm_source=tag-newest（这个好像是jdk1.9的ArrayList分析）
看了上面参考里的源码分析和自己看源码，就记录一下自己的所得，大多都是复制的，不过也加了自己的一些见解（文章中可能会有错误），所以写个随笔加深印象。
简介：
ArrayList也就是动态数组，底层是数组实现的。先说说数组，数组在内存中是连续存储的，它的索引速度非常快，赋值和修改元素很快捷。因为数组是连续存储的，所以Arraylist在内存中也是连续的。索引Arraylist的时候是要比原生数组慢的，因为你要用get方法，也就是函数调用，而数组就是直接[]访问，相当于直接操作内存地址，速度肯定比函数调用快。但是数组有不足，在数组的两个数据中间插入数据是很麻烦的，并且在声明数组的时候我们必须同时指定数组的长度，数组的长度过长，会造成内存浪费，数组的长度过短会造成数据的溢出错误。所以就有了Arraylist来有取舍的优化，ArrayList和Array各有优点和用处。
Array和ArrayList的一些不同点：
1、Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。
2、Array大小是固定的，ArrayList的大小是动态变化的。
3、ArrayList提供了更多的方法和特性，比如：add()，removeAll()，iterator()等等。所以ArrayList的可操作性就更强了，可以对数据方便的添加、插入和删除。（其实它的插入、删除的效率不高，LinkedList的插入、删除高）
ArrayList还存在不安全类型和装箱和拆箱的缺点，可以用泛型解决这些缺点。ArrayList还是线程不安全的，因为它里面的方法不能保证操作的原子性。
ArrayList继承了AbstractList，实现了List、RandomAccess[随机访问], Cloneable[可克隆], java.io.Serializable[序列化]。
扩展：序列化是指：将对象转换成以字节序列的形式来表示，以便用于持久化和传输。
源码分析（不是很全）（jdk1.8）
1、属性分析
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
/**
* Default initial capacity.默认初始化容量
*/
private static final int DEFAULT_CAPACITY = 10; /**如果用户自定义容量为0，默认用下面这个来初始化ArrayList，空数组 * Shared empty array instance used for empty instances. */ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when * first element is added. */这又来了一个空数组，当用户没有指定ArrayList的容量时（即调用无参构造函数），返回的是该
数组，当用户第一次添加元素是，该数组会扩容，变为默认容量为10的一个数组，在ensureCapacity（）实现
它与上一个的区别就是该数组是默认返回的，而上一个是在用户指定容量为0时返回 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. Any * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA * will be expanded to DEFAULT_CAPACITY when the first element is added. */这是我们ArrayList底层用到的数组，用transient修饰 transient Object[] elementData; // non-private to simplify nested class access /** * The size of the ArrayList (the number of elements it contains). * * @serial */ArrayList实际存储的数据数量 private int size;
transient关键字解析：
Java中transient关键字的作用，简单地说，就是让某些被修饰的成员属性变量不被序列化。
有了transient关键字声明，则这个变量不会参与序列化操作，即使所在类实现了Serializable接口，反序列后该变量为空值。
那么问题来了：ArrayList中数组声明：transient Object[] elementData;，事实上我们使用ArrayList在网传输用的很正常，并没有出现空值。
原来：ArrayList在序列化的时候会调用writeObject()方法，将size和element写入ObjectOutputStream；反序列化时调用readObject()，从ObjectInputStream获取size和element，再恢复到elementData。
那为什么不直接用elementData来序列化，而采用上诉的方式来实现序列化呢？
原因在于elementData是一个缓存数组，它通常会预留一些容量，等容量不足时再扩充容量，那么有些空间可能就没有实际存储元素，采用上诉的方式来实现序列化时，就可以保证只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间。
2、构造方法分析
/**
* 创建一个初试容量的、空的ArrayList
* @param initialCapacity初始容量
* @throws IllegalArgumentException当初始容量值非法(小于0)时抛出
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 无参构造函数：
* - 创建一个空的 ArrayList，此时其内数组缓冲区elementData = {}, 长度为 0
* - 当元素第一次被加入时，扩容至默认容量 10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 创建一个包含collection的ArrayList
* @param c 要放入 ArrayList 中的集合，其内元素将会全部添加到新建的 ArrayList 实例中
* @throws NullPointerException 当参数 c 为 null 时抛出异常
*/
public ArrayList(Collection<? extends E> c) {
//将集合转化成Object[]数组
elementData = c.toArray();
//把转化后的Object[]数组长度赋值给当前ArrayList的size，并判断是否为0
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
// 这句话意思是：c.toArray 可能不会返回 Object[]，可以查看 java 官方编号为 6260652 的 bug
if (elementData.getClass() != Object[].class)
// 若 c.toArray() 返回的数组类型不是 Object[]，则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 替换空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
3、主干方法
trimToSize（）方法，这个方法用来最小化实例存储
public void trimToSize() {
// modCount 是 AbstractList 的属性值：protected transient int modCount = 0;
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
这个方法里面突然混进了一个modCount，这个数了作用是为了记录修改次数，而且这个数在本数据结构对应迭代器iterator中很重要，（Fail-Fast机制（快速失败机制））ArrayList是线程不安全的，在使用迭代器遍历List时有其他线程修改了List，会抛出java.util.ConcurrentModificationException异常。Itr类里有一个成员变量expectedModCount，它的值为创建Itr对象的时候List的modCount值。用此变量来检验在迭代过程中List对象是否被修改了，如果被修改了则抛出java.util.ConcurrentModificationException异常。更具体的可以看下面这个链接里面的
https://blog.csdn.net/ljw619/article/details/79150635（ArrayList中的modCount的作用）
下面是ArrayList的扩容机制
public void ensureCapacity(int minCapacity) {
// 最小扩充容量，默认是 10
//判断是不是空的ArrayList,如果是的最小扩充容量10，否则最小扩充量为0
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0
: DEFAULT_CAPACITY;
// 若用户指定的最小容量 > 最小扩充容量，则以用户指定的为准，否则还是 10
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
这上面一个ensureCapacity方法中minExpand这个参数我一开始没看懂，这个方法是提供给用户用的，感觉没啥用，在我的jkd1.9里面是把这个方法和下面一个方法合并了，在ArrayList的实现中并没有使用。我大概理解就是当我们的elementData为空的时候minExpand=10，我们指定的minCapacity如果大于minExpand（10），就会执行ensureExplicitCapacity（minCapacity）方法，如果elementData不为空则minExpand=0，我们指定的minCapacity大于minExpand（0），执行ensureExplicitCapacity（minCapacity）方法。如果有必要，增加ArrayList实例的容量，以确保它至少能容纳的数量。如果我们要看容量的话要用反射来看，size（）方法得到的是列表中的元素的个数而不是容量。
private void ensureCapacityInternal(int minCapacity) {
// 若 elementData == {}，则取 minCapacity 为 默认容量和参数 minCapacity 之间的最大值
// 注：ensureCapacity() 是提供给用户使用的方法，在 ArrayList 的实现中并没有使用
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity= Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
上面这个ensureCapacityInternal方法是我们ArrayList实现中的方法，得到做小的扩容量
/**
* 私有方法：明确 ArrayList 的容量
* - 用于内部优化，保证空间资源不被浪费：尤其在 add() 方法添加时起效
* @param minCapacity 指定的最小容量
*/
private void ensureExplicitCapacity(int minCapacity) {
// 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的
modCount++;
// 防止溢出代码：确保指定的最小容量 > 数组缓冲区当前的长度
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
ensureExplicitCapacity（）判断是否需要扩容
在我的jdk1.9中是直接把上面这三个方法直接整合了，扩容直接就用grow（）和newCapacity（），在add方法里直接grow了可以在此看一看 https://segmentfault.com/a/1190000019326016?utm_source=tag-newest（jdk1.9的ArrayList分析）
MAX_ARRAY_SIZE常量
/** * 数组缓冲区最大存储容量 * - 一些 VM 会在一个数组中存储某些数据--->为什么要减去 8 的原因 * - 尝试分配这个最大存储容量，可能会导致 OutOfMemoryError(当该值 > VM 的限制时) */ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
grow（）扩容方法
/**
* 私有方法：扩容，以确保 ArrayList 至少能存储 minCapacity 个元素
* - 扩容计算：newCapacity = oldCapacity + (oldCapacity >> 1); 扩充当前容量的1.5倍
* @param minCapacity 指定的最小容量
*/
private void grow(int minCapacity) {
// 防止溢出代码
int oldCapacity = elementData.length;
// 运算符 >> 是带符号右移. 如 oldCapacity = 10,则 newCapacity = 10 + (10 >> 1) = 10 + 5 = 15
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0) // 若 newCapacity 依旧小于 minCapacity
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) // 若 newCapacity 大于最大存储容量，则进行大容量分配
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
hugeCapacity（）方法
/**
* 私有方法：大容量分配，最大分配 Integer.MAX_VALUE
* @param minCapacity
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
size（）、isEmpty（）、contains（）、indexOf（）、lastIndexOf（）
/**
* 返回ArrayList实际存储的元素数量
*/
public int size() {
return size;
}
/**
* ArrayList是否有元素
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含o元素
*/
public boolean contains(Object o) {
// 根据 indexOf() 的值(索引值)来判断，大于等于 0 就包含
// 注意：等于 0 的情况不能漏，因为索引号是从 0 开始计数的
return indexOf(o) >= 0;
}
/**
* 顺序查找，返回元素的最低索引值(最首先出现的索引位置)
* @return 存在？最低索引值：-1
*/
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;
}
/**
* 逆序查找，返回元素的最低索引值(最首先出现的索引位置)
* @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;
}
toArray()
/**
* 返回 ArrayList 的 Object 数组
* - 包含 ArrayList 的所有储存元素
* - 对返回的该数组进行操作，不会影响该 ArrayList（相当于分配了一个新的数组）==>该操作是安全的
* - 元素存储顺序与 ArrayList 中的一致
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
rangeCheck（）
/**
* 检查数组是否在界线内
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
add()
public boolean add(E e) {
// 确定ArrayList的容量大小---严谨
// 注意：size + 1，保证资源空间不被浪费，
// ☆☆☆按当前情况，保证要存多少个元素，就只分配多少空间资源
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/**
*
*在这个ArrayList中的指定位置插入指定的元素，
* - 在指定位置插入新元素，原先在 index 位置的值往后移动一位
* @param index 指定位置
* @param element 指定元素
* @throws IndexOutOfBoundsException
*/
public void add(int index, E element) {
rangeCheckForAdd(index);//判断角标是否越界
//看上面的，size+1，保证资源空间不浪费，按当前情况，保证要存多少元素，就只分配多少空间资源
ensureCapacityInternal(size + 1); // Increments modCount!!
//第一个是要复制的数组，第二个是从要复制的数组的第几个开始，
// 第三个是复制到那，四个是复制到的数组第几个开始，最后一个是复制长度
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
还有很多方法就不列举了，可以去上面的参考链接里面有。
在add（）方法中的size+1问题
size+1代表的含义是：
1、如果集合添加元素成功后，集合中的实际元素个数。
2、为了确保扩容不会出现错误。
假如不加一处理，如果默认size是0，则0+0>>1还是0。
如果size是1，则1+1>>1还是1。有人问:不是默认容量大小是10吗?事实上，jdk1.8版本以后，ArrayList的扩容放在add()方法中。之前放在构造方法中。我用的是1.8版本，所以默认ArrayList arrayList = new ArrayList();后，size应该是0.所以,size+1对扩容来讲很必要.
手写ArrayList，缩减版
/**
* @program: IdeaJava
* @Date: 2020/1/7 15:13
* @Author: lhh
* @Description:
*/
public class MyArrayList {
transient Object[] elementData;
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private int size;
public MyArrayList(int initialCapacity)
{
if(initialCapacity > 0)
{
this.elementData = new Object[initialCapacity];
}else if (initialCapacity == 0)
{
this.elementData = EMPTY_ELEMENTDATA;
}else
{
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public MyArrayList()
{
this(DEFAULT_CAPACITY);
}
private void ensureExplicitCapacity(int minCapacity)
{
if(size == elementData.length)
{
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
{
newCapacity = minCapacity;
}
Object[] objects = new Object[newCapacity];
System.arraycopy(elementData,0,objects,0,elementData.length);
elementData = objects;
}
}
public void add(Object o)
{
ensureExplicitCapacity(size + 1);
elementData[size++] = o;
}
public void add(int index ,Object o)
{
rangeCheck(index);
ensureExplicitCapacity(size + 1);
System.arraycopy(elementData,index,elementData,index+1,size-index);
elementData[index] = o;
size++;
}
private void rangeCheck(int index)
{
if (index >= size)
throw new IndexOutOfBoundsException("下标越界");
}
public Object get(int index)
{
rangeCheck(index);
return elementData[index];
}
public Object remove(int index)
{
rangeCheck(index);
Object oldValue = elementData[index];
int numMoved = size - index - 1;
if(numMoved > 0)
System.arraycopy(elementData,index+1,elementData,index,numMoved);
elementData[--size] = null;
return oldValue;
}
public boolean remove(Object o)
{
for(int index = 0;index < size;index++)
{
if(o.equals(elementData[index]))
{
remove(index);
return true;
}
}
return false;
}
public int getSize()
{
return size;
}
}