前言

要想深入的了解集合就必须要通过分析源码来了解它，那如何来看源码，要看什么东西呢？主要从三个方面：

看这个类的继承结构，处于一个什么样的位置，不需要背记，有个大概的感觉就可以。
看构造方法：很重要，一般构造方法中会做很多的事情，要跟踪方法中的方法。
看常用方法：没必要所有的方法都要去了解，要知道常用的，核心的方法即可。

ArrayList的概述

ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类。
该类封装了一个动态再分配的Object[]数组，每一个类对象都有一个capacity属性，表示它们所封装的Object[]数组的长度，当向ArrayList中添加元素的时候，该属性值会自动增加。
如果想ArrayList中添加大量的元素，可使用ensureCapacity方法一次性增加capacity，可以减少重分配的次数提高性能。
ArrayList的用法和Vector类似，但是Vector是一个较老的集合，具有很多缺点，不建议使用。
ArrayList和Vector的区别是：Arrayist是线程不安全的，当多条线程访问同一个List集合的时候，程序需要手动保证该集合的同步性，而Vector则是线程安全的。

继承关系图：

源码分析

1. 继承结构和层次关系

分析：为什么要让AbstractList先实现List,然后在让ArrayList继承AbstractList？为什么不让ArrayList直接实现List?

这里是一种默认的写法，也可以说是一种思想：让AbstractList去实现接口中一些通用的方法，而具体的类ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后去实现一些自己特有的方法。

这样一来代码更加简洁，并且如果有多个类继承List,就可以直接继承AbstractList的通用方法，减少重复的代码。所以一般看到一个类上面还有一个抽象类，应该就是这个作用。

2. 类中属性

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 版本号
    private static final long serialVersionUID = 8683452581122892189L;
    // 缺省容量
    private static final int DEFAULT_CAPACITY = 10;
    // 空对象数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 缺省空对象数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 元素数组
    transient Object[] elementData;
    // 实际元素大小，默认为0
    private int size;
    // 最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}

3. 构造方法

ArrayList有三个构造方法：

无参构造方法

DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空的Object[],将elementData初始化，elementData也是一个Object[]类型。空的Object[]会给默认大小10，等会解释什么时候赋值的。

ArrayList中存储数据的其实就是一个数组，这个数组就是elementData。

有参构造函数（就是自定义初始的容量）

有参构造函数2（不常用）

总结：arrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫做elementData。

4. 核心方法

4.1

添加方法共有四个，这里只介绍常用的两种。

boolean add(E); //默认直接在末尾添加元素

分析： ensureCapacityInternal方法为确定容量的方法，在添加元素之前需要确定数组是否能放的下，size是数组中的数据的个数，因为要添加一个元素，所以要size+1。

ensureCapacityInternal方法中分两步： a: 首先确定最小容量：判断elementData==DEFAULTCAPACITY_EMPTY_ELEMENTDATA,即判断初始化的elementData是不是空的数组。然后找出默认容量和参数容量中大的那个。 b:调用ensureExplicitCapacity方法，该方法才是真的判断容量是否够用的方法，如果不够则扩容

在ensureExplicitCapacity方法中，如果需要的容量大于elementData的容量，则调用grow方法进行扩容，grow方法是真正的扩容方法。

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;  //将扩充前的elementData大小给oldCapacity
        int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity就是1.5倍的oldCapacity
        
        //这句话就是适应于elementData就空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10.前面的工作都是准备工作。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacity
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
    //新的容量大小已经确定好了，就copy数组，改变容量大小咯。
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

hugeCapacity();

//这个就是上面用到的方法，很简单，就是用来赋最大值。
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
　　//如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。
　　//Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

void add(int E):在特定的位置添加元素，也就是插入元素

public void add(int index, E element) {
        rangeCheckForAdd(index);//检查index也就是插入的位置是否合理。

//跟上面的分析一样，具体看上面
        ensureCapacityInternal(size + 1);  // Increments modCount!!
//这个方法就是用来在插入元素之后，要将index之后的元素都往后移一位，
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
//在目标位置上存放元素
        elementData[index] = element;
        size++;//size增加1
    }

分析：

rangeCheckForAdd方法

注意，当调用空的构造函数创建ArrayList的时候，初始化List的大小是在第一次添加的的时候进行的。

4.2 删除方法

remove(int):通过删除指定位置上的元素

public E remove(int index) {
        rangeCheck(index);//检查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;
    }

remove(Object):这个方法可以看出来，arrayList是可以存放null值的

这里的fastRemove方法的具体实现如下

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():将elementData中的每个元素都赋值为null,等待垃圾回收将这个给回收掉，所以叫clear

removeAll(Collection c)批量删除

batchRemove(xx,xx)

//这个方法，用于两处地方，如果complement为false，则用于removeAll如果为true，则给retainAll()用，retainAll（）是用来检测两个集合是否有交集的。
   private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData; //将原集合，记名为A
        int r = 0, w = 0;   //r用来控制循环，w是记录有多少个交集
        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) {
　　//这里有两个用途，在removeAll()时，w一直为0，就直接跟clear一样，全是为null。
　　//retainAll()：没有一个交集返回true，有交集但不全交也返回true，而两个集合相等的时候，返回false，所以不能根据返回值来确认两个集合是否有交集，而是通过原集合的大小是否发生改变来判断，如果原集合中还有元素，则代表有交集，而元集合没有元素了，说明两个集合没有交集。
                // 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;
    }

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;
    }

5. 总结

arrayList可以存放null
arrayList本质上就是一个elementData数组
arrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是grow()方法
arrayList中removeAll(Collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是删除集合中的全部元素
arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，因为需要移动很多数据才能达到应有的效果
arrayList实现了RandomAccess,所以在遍历它的时候推荐使用for循环

ArrayList源码解析

前言