前言：
既然是看源码那我们要怎么看一个类的源码呢？这里我推荐的方法是：
1）看继承结构
看这个类的层次结构，处于一个什么位置，可以在自己心里有个大概的了解。
2）看构造方法
在构造方法中，看做了哪些事情，跟踪方法中里面的方法。
3）看常用的方法
跟构造方法一样，这个方法实现功能是如何实现的
注：既然是源码，为什么要这样设计类，有这样的继承关系。这就要说到设计模式的问题了。所以我们要了解常用的设计模式，才能更深刻的去理解这个类。
一：ArrayList简介
1.1、ArrayList概述
- ArrayList是可以动态增长和缩减的索引序列，它基于数组实现的List类。
- 该类封装了一个动态再分配的Object【】数组，每一个类对象都有一个capacity属性，表示他们所封装的Object【】数组长度，当向ArrayList中添加元素时，该属性值会自动增加。如果想在ArrayList中添加大量元素，可使用ensureCapacity方法一次性添加capacity，可以减少增加重分配的次数，提高性能。
- ArrayList的用法和Vector向类似，但是Vector是一个较老的集合，具有很多缺点，不建议使用。另外，ArrayList和Vector的区别是：ArrayList是线程不安全的，当多条线程访问同一个ArrayList集合时，程序需要手动保证该集合的同步性，而Vector则是线程安全的。
ArrayList的数据结构
分析一个类的时候，数据结构往往是它的灵魂所在，理解底层的数据结构其实就理解了该类的实现思路，具体的实现细节再具体分析。
ArrayList的数据结构是：
说明：底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。
二、ArrayList源码分析
2.1、继承结构和层次关系
public class ArrayList
public abstract class AbstractList
分析：
为什么要先继承AbstractList，而让AbstractList先实现List
？而不是让ArrayList直接实现List ？ 这里是有一个思想，接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，正是利用了这一点，让AbstractList是实现接口中一些通用的方法，而具体的类，
如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己在实现一些自己特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来，
先一起实现了，减少重复代码。所以一般看到一个类上面还有一个抽象类。
2.2、类中的属性
public class ArrayList
2.3、构造方法
ArrayList有三个构造方法：
1）无参构造方法
/** * 默认会给10的大小，所以一开始arrayList的容量就是10 */ public ArrayList() { //是个空的Object[]，将elementData初始化，elementData也是个Object[]类型。空的object[]会默认赋值为10，后面会提到什么时候赋值 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
备注：
transient Object[] elementData;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
2）有参构造函数一
public ArrayList(Collection<? extends E> c) { //转换为数组 elementData = c.toArray(); //判断数组中的数据个数 if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) //每个集合的toArray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么就要使用ArrayList方法去改造下。 if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
总结：arrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。
2.4、核心方法
2.4.1、add()方法（有四个）
1）boolean add(E)；//默认直接在末尾添加元素
//添加一个特定的元素到list末尾 public boolean add(E e) { //确定内部容量是否够了，size是数组中数据的个数，因为要添加一个元素，所以size+1,先判断size+1这个个数在数组中是否放的下，就在这个方法中去判断是否数组.length是否够用了。 ensureCapacityInternal(size + 1); // Increments modCount!! //在数据中正确的位置放上元素e,并且size++ elementData[size++] = e; return true; }
分析：ensureCapacityInternal(xxx); 确定内部容量的方法
private void ensureCapacityInternal(int minCapacity) { //先判断初始化的elementData是否为空数组，也就是没有长度 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //因为如果是空的化，minCapacity =size+1;其实就是等于1，空的数组没有长度就存不了了，所以就将minCapacity变成10，也就是默认大小，但是在这里，还没有真正初始化这个elementData的大小 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } //确认实际容量，上面只是将minCapacity =10，这个方法就是真正的判断elementData是否够用 ensureExplicitCapacity(minCapacity); }
ensureExplicitCapacity(xxx)；
private void ensureExplicitCapacity(int minCapacity) { modCount++; //判断minCapacity 如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。 //1、minCapacity=size+1=1——>minCapacity=10,elementData.length =0 //2、minCapacity=size+1=11,elementData.length=10,结果>0就要去扩容，这里举个例子 if (minCapacity - elementData.length > 0) //自动扩展大小 grow(minCapacity); }
grow(xxx); arrayList核心的方法，能扩展数组大小的真正秘密。
private void grow(int minCapacity) { // 将扩容前的elementData大小给oldCapacity int oldCapacity = elementData.length; //newCapacity =（1.5*oldCapacity） int newCapacity = oldCapacity + (oldCapacity >> 1); //newCapacity =0，minCapacity =10 if (newCapacity - minCapacity < 0) **//newCapacity =10** newCapacity = minCapacity; **//如果newCapacity超过了最大容量限制，就调用hugeCapacity，也就是将给的最大值给newCapacity** if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // 新的容量大小已经确定好了，就copy数组，改变容量大小了 elementData = Arrays.copyOf(elementData, newCapacity); }
hugeCapacity();
//用来赋最大值 private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); **//两层防护** return (minCapacity > MAX_ARRAY_SIZE) ? //Integer.MAX_VALUE:2147483647 Integer.MAX_VALUE : //MAX_ARRAY_SIZE=2147483639 MAX_ARRAY_SIZE; }
2）void add(int，E)；在特定位置添加元素，也就是插入元素
public void add(int index, E element) { //检测index，也就是插入的位置是否合理 rangeCheckForAdd(index); //分析过了 ensureCapacityInternal(size + 1); // Increments modCount!! //这个方法就是用在插入元素之后，要将index之后的元素都往后移动一位 System.arraycopy(elementData, index, elementData, index + 1, size - index); //在目标位置上存存放元素 elementData[index] = element; //size+1 size++; }
分析：rangeCheckForAdd(index)
private void rangeCheckForAdd(int index) { //插入的位置肯定不能大于size和小于0 if (index > size || index < 0) //如果是，则数组越界异常 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
System.arraycopy(...)：就是将elementData在插入位置后的所有元素往后面移一位。
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
src：源对象 srcPos：源对象对象的起始位置 dest：目标对象 destPost：目标对象的起始位置 length：从起始位置往后复制的长度。
总结：
正常情况下会扩容1.5倍，特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值。
当我们调用add方法时，实际上的函数调用如下：
说明：程序调用add，实际上还会进行一系列调用，可能会调用到grow，grow可能会调用hugeCapacity。
举例说明一：
ArrayList
说明：初始化lists大小为0，调用的ArrayList()型构造函数，那么在调用lists.add(8)方法时，会经过怎样的步骤呢？下图给出了该程序执行过程和最初与最后的elementData的大小。
说明：我们可以看到，在add方法之前开始elementData = {}；调用add方法时会继续调用，直至grow，最后elementData的大小变为10，之后再返回到add函数，把8放在elementData[0]中。
举例说明二：
ArrayList
说明：调用的ArrayList(int)型构造函数，那么elementData被初始化为大小为6的Object数组，在调用add(8)方法时，具体的步骤如下：
说明：我们可以知道，在调用add方法之前，elementData的大小已经为6，之后再进行传递，不会进行扩容处理。
2.4.2、删除方法
其实这几个删除方法都是类似的。我们选择几个讲，其中fastRemove(int)方法是private的，是提供给remove(Object)这个方法用的。
1）remove(int)：通过删除指定位置上的元素
public E remove(int index) { //检测index的合理性 rangeCheck(index); //这个作用很多，比如检测快速失败的一种标志 modCount++; //通过索引直接找到该元素 E oldValue = elementData(index); //计算要移动的位数 int numMoved = size - index - 1; if (numMoved > 0) //移动元素 System.arraycopy(elementData, index+1, elementData, index, numMoved); //将--size上的位置赋值为null，让gc（垃圾回收机制）更快的回收它 elementData[--size] = null; // clear to let GC do its work //返回删除的元素 return oldValue; }
2）remove(Object)：这个方法可以看出来，arrayList是可以存放null值得。
//通过元素来删除该元素，就依次遍历，就将该元素的索引传给fastRemove（index），使用这个方法来删除该元素 public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; }
//和remove方法实现差不多 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 }
3）clear()：将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉，所以叫clear
/** * Removes all of the elements from this list. The list will * be empty after this call returns. */ public void clear() { modCount++; // clear to let GC do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; }
4）removeAll(collection c)：
public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); //批量删除 return batchRemove(c, false); }
5）batchRemove(xx,xx)：用于两个方法，一个removeAll()：它只清楚指定集合中的元素，retainAll()用来测试两个集合是否有交集。
private boolean batchRemove(Collection<?> c, boolean complement) { //将原集合记为A final Object[] elementData = this.elementData; //r用来控制循环，w是记录有多少个交集 int r = 0, w = 0; boolean modified = false; try { for (; r < size; r++) //参数中的集合c一次检测集合A中的元素是否有 if (c.contains(elementData[r]) == complement) //有就给集合A elementData[w++] = elementData[r]; } finally { // Preserve behavioral compatibility with AbstractCollection, // even if c.contains() throws. //如果contains方法使用过程报异常 if (r != size) { //将剩下的元素都赋值给集合A System.arraycopy(elementData, r, elementData, w, size - r); w += size - r; } if (w != size) { // clear to let GC do its work for (int i = w; i < size; i++) elementData[i] = null; modCount += size - w; size = w; modified = true; } } return modified; }
总结：：remove函数用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，
2.4.3、set()方法
public E set(int index, E element) { //检测索引是否合法 rangeCheck(index); //旧值 E oldValue = elementData(index); //赋新值 elementData[index] = element; //返回旧值 return oldValue; }
说明：设定指定下标索引的元素值
2.4.4、indexOf()方法
//从首开始查找数组中是否存在指定元素 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; }
说明：从头开始查找与指定元素相等的元素，注意，是可以查找null元素的，意味着ArrayList中可以存放null元素的。与此函数对应的lastIndexOf，表示从尾部开始查找。
2.4.5、get()方法
public E get(int index) { //检测索引合法性 rangeCheck(index);
return **elementData**(index);
}
说明：get函数会检查索引值是否合法（只检查是否大于size，而没有检查是否小于0），值得注意的是，在get函数中存在element函数，element函数用于返回具体的元素，具体函数如下：
E elementData(int index) { return (E) elementData[index]; }
说明：返回的值都经过了向下转型（Object -> E），这些是对我们应用程序屏蔽的小细节。
三、总结
1、arrayList是可以存放null。
2、arrayList本质就是一个elementData数组。
3、arrayList区别于数组的地方在于能够自动扩展大小，其中关键方法就是grow（）方法
4、arrayList中的removeAll（Collection c）和clear（）的区别就是removeAll可以删除批量指定元素，而clear是全是删除集合中的元素。
5、arrayList由于本质是数组，所以它在暑假查询方面会很快，而在插入删除这些方面，性能下降很多，要移动很多数据才能达到应有的效果。
6、arrayList实现了RandomAccess,所以在遍历它的时候推荐使用for循环
补充：RandomAccess接口：这个是一个标记性接口，通过查看api文档，它的作用就是用来快速随机存取，有关效率的问题，在实现了该接口的话，那么使用普通的for循环来遍历，性能更高，例如arrayList。
