JDK1.8 ArrayList源码

属性

    //序列号
    private static final long serialVersionUID = 8683452581122892189L;
    //默认初始容量
    private static final int DEFAULT_CAPACITY = 10;
    //空数组
    /*
        调用public ArrayList(int initialCapacity)时，initialCapacity==0时，
        将该值赋值给elementData
    */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /*
        调用public ArrayList()时，将该值赋值给elementData
    */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //底层数组
    //ArrayList底层用数组实现，说的就是该数组
    transient Object[] elementData; 
    //元素个数
    //元素个数小于等于底层数组长度
    private int size;

构造方法

第一种

    //只是将空数组的引用传给底层数组
    //别的什么操作都没做
    //当添加元素的时候，才会进行扩容操作
    //扩容操作会在add()方法中解释
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

第二种

    //该方法入参为 实现Collection接口的子类
    //若参数c的长度大于0，将参数中的元素复制到elementData数组中
    //若参数c的长度大于0，将elementData数组置为空数组
    public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

第三种

    //参数为 指定的elementData的长度
    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);
        }
    }

 add(E e)  主要扩容机制

    //modCount为修改次数，是父类AbstractList的属性
    //主要步骤 add(e, elementData, size);
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }

    //当数组中的元素个数等于数组的长度时，就会执行  扩容操作  

    //扩容的第一种情况（elementData.length==0）
    //第一次添加数据时（默认的调用的无参数的构造方法），s==0且elementData.length==0
    //所以会执行  扩容操作。
    //调用private Object[] grow(int minCapacity)方法，参数为1
    //会执行else 里的代码,底层数组的长度变为  DEFAULT_CAPACITY（=10）

    //扩容的第二种情况（elementData.length!=0&&s==elementData.length）
    //例如：数组中有了10位元素，再添加新元素时会执行  扩容操作
    //调用private Object[] grow(int minCapacity)方法，参数为11
    //会执行if 里的代码，底层数组的长度变为  原先长度+(原先长度>>1)
    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

    private Object[] grow() {
        return grow(size + 1);
    }

    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }
    
    //该方法是ArraysSupport类的
    public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
        // assert oldLength >= 0
        // assert minGrowth > 0

        int newLength = Math.max(minGrowth, prefGrowth) + oldLength;
        if (newLength - MAX_ARRAY_LENGTH <= 0) {
            return newLength;
        }
        return hugeLength(oldLength, minGrowth);
    }

add方法总结，方便记忆：第一次扩容时，数组长度变为10。除了第一次，其他扩容时候，数组长度变为原先长度的1.5倍数。

        //可以debug以下代码段查看扩容的过程
        //可以在i==1和i==11时，设置条件断点。
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 1; i <= 16; i++) {

            list.add(i);

        }

remove（int index）

    //删除数组中的对应下标的元素
    public E remove(int index) {
        Objects.checkIndex(index, size);
        final Object[] es = elementData;

        @SuppressWarnings("unchecked") E oldValue = (E) es[index];
        fastRemove(es, index);

        return oldValue;
    }
    
    //if 判断的意思是：若删除的元素不是最后一个，则将该位置后面的元素向前移
    private void fastRemove(Object[] es, int i) {
        modCount++;
        final int newSize;
        if ((newSize = size - 1) > i)
            System.arraycopy(es, i + 1, es, i, newSize - i);
        es[size = newSize] = null;
    }