1. ArrayList的继承结构图

继承结构图

从继承结构图中可以看出来,,一般的设计都会是List接口定义所有的API接口,然后用抽象类AbstractList来实现常用的API接口,然后在实现类中定义具体的实现;

接口 ==> 抽象类 ==> 类

图中,ArrayList却去实现了List ,collection 的作者Josh说他写这代码的时候觉得这个会有用处，但是其实并没什么用，但因为没什么影响，就一直留到了现在。

2.ArrayList 的成员变量

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //序列化和反序列化id
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 指定该ArrayList容量为0时，返回该空数组。
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 当调用无参构造方法，返回的是该数组。
     * 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 存放数据的数组
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList的实际大小
     */
    private int size;

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * ArrayList的最大容量;  -8  是因为JVM在数组中保留一些header。
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

3. ArrayList 的构造方法

3.1 无参构造器

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;  
    }
}

当我们通过 ArrayList<String> arrayList = new ArrayList<>(); 时, 会将常量数组对象DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给 elementData 对象数组;
因为使用到空构造的情况很多,所以将DEFAULTCAPACITY_EMPTY_ELEMENTDATA定义为常量,主要为了节约空间

3.2 带容量的构造器

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public ArrayList(int initialCapacity) {
        // 如果指定的容量大于0, 创建一个对象数组,指定容量为传入的参数,并赋值给elementData
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        // 如果指定的容量为0的话,将空的对象数组EMPTY_ELEMENTDATA赋值给elementData
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        //参数异常
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
}

3.3 带集合的构造器

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public ArrayList(Collection<? extends E> c) {
        //将集合转化为数组,赋值给elementData 
        elementData = c.toArray();
        // 若数组elementData的长度不等于0
        if ((size = elementData.length) != 0) {
            //每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么就需要使用ArrayList中的方法去改造一下。
            if (elementData.getClass() != Object[].class)
                //将传入的数组赋值给elementData
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 若数组elementData的长度等于0
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
}

4. ArrayList 的常用方法

4.1 add(E e)方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e; //在数组的末尾增加元素
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        //minCapacity: 添加元素过后,ArrayList的大小
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    //获取ArrayList的最大容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //如果ArrayList为空,则表示数组未初始化,则返回DEFAULT_CAPACITY
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;   // 记录操作数
        // 若数组的容量大于了数组的长度,就扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    // 扩容, 扩容1.5倍,并赋值为新的数组
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        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);
    }
}

4.2 add(int index, E element)方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

    public void add(int index, E element) {
        rangeCheckForAdd(index); // 校验数组下标

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将指定元素插入到列表中的指定位置。将当前位于该位置的元素(如果有的话)和随后的任何元素向右移动。
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
}

4.3 remove(int index)方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public E remove(int index) {
        rangeCheck(index); // 检查下标

        modCount++;
        E oldValue = elementData(index);  //旧值

        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  将最后的一个元素置空

        return oldValue; // 返回删除的值
    }
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

}

4.4 remove(Object o)方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   public boolean remove(Object o) {
        //ArrayList可以存放null
        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;
    }

    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
    }

}

4.5 set(int index, Object o)方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
       public E set(int index, E element) {
        rangeCheck(index);.// 检查数组下标
        E oldValue = elementData(index);// 获取旧值
        elementData[index] = element; //赋值新值
        return oldValue;  //返回旧值
    }

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
}

4.6 E get(int index)方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public E get(int index) {
        rangeCheck(index);// 检查数组索引
        return elementData(index);//返回索引对应的元素
    }

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
}

4.7 clear()方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public void clear() {
        modCount++;
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        size = 0;
    }
}