Java集合之 ArrayList源码解析

ArrayList 源码

非线程安全的可重复元素顺序列表

继承AbstractList（骨架实现）；

实现了Cloneable，其中的clone方法使用了Arrays.copyOf，为数组拷贝浅克隆；

实现了序列化接口，并自定义了readObject、writeObject方法

顺序列表采用数组实现，数组长度与元素个数size并不一致，有冗余的空间

实现了RandomAccess接口，可快速的进行下标查询操作（算法时间复杂度O(1)）；

插入、删除到指定位置时需要进行移动后续的所有元素（算法时间复杂度O(n)）

重点方法：

1、构造器，提供三个构造：无参、容量参数、集合参数的拷贝构造器

JDK1.6版本

    public ArrayList(int initialCapacity) {        super();//调用父类无参构造（protected空方法，这样其子类可选择实现序列化）        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        this.elementData = new Object[initialCapacity];    }    public ArrayList() {        this(10);//调用有参构造，默认容量10    }    public ArrayList(Collection<? extends E> c) {//拷贝构造器，支持任意集合；支持子类        elementData = c.toArray();        size = elementData.length;        // c.toArray might (incorrectly) not return Object[] (see 6260652)       if (elementData.getClass() != Object[].class)             elementData = Arrays.copyOf(elementData, size, Object[].class);//拷贝的数组Object对象，浅拷贝    }

JDK1.8版本（1.7调整增加了几个容量常量，默认空数组）

    private static final int DEFAULT_CAPACITY = 10;//默认容量，1.7新增    private static final Object[] EMPTY_ELEMENTDATA = {};//空数组，1.7新增    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//默认空容量数组，1.7新增    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);        }    }    public ArrayList() {//默认空数组        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }    public ArrayList(Collection<? extends E> c) {        elementData = c.toArray();        if ((size = elementData.length) != 0) {            // c.toArray might (incorrectly) not return Object[]            if (elementData.getClass() != Object[].class)                elementData = Arrays.copyOf(elementData, size, Object[].class);        } else {            // replace with empty array.            this.elementData = EMPTY_ELEMENTDATA;        }    }

2、数组长度扩展，为减少扩展次数，设定了较为统一的扩容办法

JDK1.6版本

    public void ensureCapacity(int minCapacity) {//保证数组长度，如果不够，进行增加        modCount++;        int oldCapacity = elementData.length;        if (minCapacity > oldCapacity) {            Object oldData[] = elementData;//未有使用            int newCapacity = (oldCapacity * 3)/2 + 1;//默认扩容计算方法，不够直接使用传入的minCapacity                if (newCapacity < minCapacity)                    newCapacity = minCapacity;                // minCapacity is usually close to size, so this is a win:                elementData = Arrays.copyOf(elementData, newCapacity);//数组副本        }    }

JDK1.8版本（1.7调整主要增加了最大长度判断及使用移位运算增加了扩容性能）

    public void ensureCapacity(int minCapacity) {//对外公共的容量增加方法，内部未调用        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)            // any size if not default element table            ? 0            // larger than default for default empty table. It's already            // supposed to be at default size.            : DEFAULT_CAPACITY;//第一次增加必须传入比默认容量大的数据，否则不会进行容量增加【写反了？？】        if (minCapacity > minExpand) {            ensureExplicitCapacity(minCapacity);        }    }    private void ensureCapacityInternal(int minCapacity) {//内部容量增加方法        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//最小容量为默认容量与最小容量的最大值，确保第一次增加传入默认容量        }        ensureExplicitCapacity(minCapacity);    }    private void ensureExplicitCapacity(int minCapacity) {//容量增加判断方法，容量不够则新增        modCount++;        //判断如果容量不够则进行扩容        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//最大数组长度，1.7新增    private void grow(int minCapacity) {//普通数组容量增加实现方法        int oldCapacity = elementData.length;//原始容量        int newCapacity = oldCapacity + (oldCapacity >> 1);//移位运算，右移相当于除以2        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE > 0)//超出最大数组长度，调用大容量方法防止直接内存溢出            newCapacity = hugeCapacity(minCapacity);        elementData = Arrays.copyOf(elementData, newCapacity);//按计算出的长度进行数组创建    }    private static int hugeCapacity(int minCapacity) {        if (minCapacity < 0) // overflow            throw new OutOfMemoryError();        return (minCapacity > MAX_ARRAY_SIZE) ?            Integer.MAX_VALUE :            MAX_ARRAY_SIZE;//返回最大数组长度或int最大值    }

3、toArray，提供数组的转换办法

    public Object[] toArray() {//返回新的Object数组（但并不要求保证深拷贝）        return Arrays.copyOf(elementData, size);    }        public <t> T[] toArray(T[] a) {        if (a.length < size)//如果对方数组长度小于当前list，那么直接返回当前list对应的泛型数组            return (T[]) Arrays.copyOf(elementData, size, a.getClass());        System.arraycopy(elementData, 0, a, 0, size);//复制list到对方数组，位置不变，native方法        if (a.length > size)//如果对方数组长度大于当前list，那么第size个元素设置为空            a[size] = null;        return a;    }</t>

4、remove、clear 不减少数组长度，只修改size，但需将数组元素之为空以便进行垃圾回收

    public E remove(int index) {//删除指定位置的数据，并返回该元素        RangeCheck(index);            modCount++;//修改次数+1        E oldValue = (E) elementData[index];            int numMoved = size - index - 1;        if (numMoved > 0)            System.arraycopy(elementData, index+1, elementData, index, numMoved);//复制数组位置前移，native方法        elementData[--size] = null; //减少list长度，并将最后一个数据置空以便进行垃圾回收        return oldValue;    }        public void clear() {//清空list        modCount++;        //数组清空        for (int i = 0; i < size; i++)            elementData[i] = null;            size = 0;//长度置0    }

5、迭代器模式

JDK1.6 使用了父类的迭代器，JDK1.7内部实现了具体的迭代器实现类进行使用；

该迭代器将迭代操作与集合进行了分离；是一个fail-fast 迭代器，这意味着它假设线程在集合内容中进行迭代时，集合不会更改它的内容。如果 fail-fast 迭代器检测到在迭代过程中进行了更改操作，那么会抛出 ConcurrentModificationException 。 

6、1.7重写了removeAll、retainAll方法；不再使用AbstractCollection的这两个方法

    public boolean removeAll(Collection<?> c) {//1.7 重写removeAll方法        Objects.requireNonNull(c);//确保集合非空        return batchRemove(c, false);    }    public boolean retainAll(Collection<?> c) {//1.7 重写retainAll方法        Objects.requireNonNull(c);        return batchRemove(c, true);    }    private boolean batchRemove(Collection<?> c, boolean complement) {//1.7 增加快速删除方法，不使用迭代器遍历的方式处理        final Object[] elementData = this.elementData;        int r = 0, w = 0;        boolean modified = false;        try {            for (; r < size; r++)//循环当前列表数组                if (c.contains(elementData[r]) == complement)//逐个判断是否存在于c集合中，顺序记录需要保留的数据                    elementData[w++] = elementData[r];        } finally {            // Preserve behavioral compatibility with AbstractCollection,            // even if c.contains() throws.            if (r != size) {//循环未正常结束，进行对剩余数组的位置移动操作                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;    }