【Java集合源码剖析1.1】ArrayList源码剖析（API23）

首先
public class ArrayList extends AbstractList implements Cloneable, Serializable, RandomAccess
ArrayList类实现了这三个接口， 具有可复制的，可序列化的，以及快速随机访问的特性。

一， 构造函数

    public ArrayList(int capacity) {  // EmptyArray.OBJECT 其实就是new Object[0])；
        if (capacity < 0) {
            throw new IllegalArgumentException("capacity < 0: " + capacity);
        }
        array = (capacity == 0 ? EmptyArray.OBJECT : new Object[capacity]);
    }

    public ArrayList() {
        array = EmptyArray.OBJECT;
    }

    public ArrayList(Collection collection) {
        if (collection == null) {
            throw new NullPointerException("collection == null");
        }

        Object[] a = collection.toArray();
        if (a.getClass() != Object[].class) {
            Object[] newArray = new Object[a.length];
            System.arraycopy(a, 0, newArray, 0, a.length);
            a = newArray;
        }
        array = a;
        size = a.length;
    }

add()和addAll()方法 。

1.添加add(E object)

 @Override public boolean add(E object) {
        Object[] a = array;
        int s = size;
        if (s == a.length) {   //数组里刚好放满。（有可能 不相等， 有剩余容量 。a.length 有可能 大于size.）
            Object[] newArray = new Object[s +   //MIN_CAPACITY_INCREMENT = 12;
                    (s < (MIN_CAPACITY_INCREMENT / 2) ?   // 如果原数组个数少于6个,扩容增加12个， 否则，容量增加当前容量的一半。
                     MIN_CAPACITY_INCREMENT : s >> 1)];
            System.arraycopy(a, 0, newArray, 0, s);
            array = a = newArray;   // 替换为新数组。
        }
        a[s] = object;   //  最后设置为刚添加的数
        size = s + 1;
        modCount++;
        return true;
    }

2 .add(int index, E object) 指定添加位置

 @Override public void add(int index, E object) {
        Object[] a = array;
        int s = size;
        if (index > s || index < 0) {
            throwIndexOutOfBoundsException(index, s);
        }

        if (s < a.length) {   // 数组中有末用空间，直接添加这个数
            System.arraycopy(a, index, a, index + 1, s - index);//数组在指定位置 全部后移，
        } else {
            // assert s == a.length;
            Object[] newArray = new Object[newCapacity(s)];   // newCapacity 扩容。 
            System.arraycopy(a, 0, newArray, 0, index);   //拷贝到新数据newArray里
            System.arraycopy(a, index, newArray, index + 1, s - index);   //   /数组在指定位置 全部后移，
            array = a = newArray;                             //   设置为当前数组
        }
        a[index] = object;                  //   在指定位置插入值
        size = s + 1;
        modCount++;
    }

3,addAll(Collection collection)添加集合

 @Override public boolean addAll(Collection collection) {
        Object[] newPart = collection.toArray();
        int newPartSize = newPart.length;
        if (newPartSize == 0) {
            return false;
        }
        Object[] a = array;
        int s = size;
        int newSize = s + newPartSize; // If add overflows, arraycopy will fail
        if (newSize > a.length) {
            int newCapacity = newCapacity(newSize - 1);  // ~33% growth room
            Object[] newArray = new Object[newCapacity];
            System.arraycopy(a, 0, newArray, 0, s);
            array = a = newArray;
        }
        System.arraycopy(newPart, 0, a, s, newPartSize);
        size = newSize;
        modCount++;
        return true;
    }

4.addAll(int index, Collection collection)指定位置添加集合

   @Override
    public boolean addAll(int index, Collection collection) {
        int s = size;
        if (index > s || index < 0) {
            throwIndexOutOfBoundsException(index, s);
        }
        Object[] newPart = collection.toArray();
        int newPartSize = newPart.length;
        if (newPartSize == 0) {
            return false;
        }
        Object[] a = array;
        int newSize = s + newPartSize; // If add overflows, arraycopy will fail
        if (newSize <= a.length) {   // 当前数组容量够用， 直接拷贝 
             System.arraycopy(a, index, a, index + newPartSize, s - index);
        } else {
            int newCapacity = newCapacity(newSize - 1);  // ~33% growth room
            Object[] newArray = new Object[newCapacity];
            System.arraycopy(a, 0, newArray, 0, index);
            System.arraycopy(a, index, newArray, index + newPartSize, s-index);
            array = a = newArray;
        }
        System.arraycopy(newPart, 0, a, index, newPartSize);
        size = newSize;
        modCount++;
        return true;
    }

前面都用到了这个关键的方法，理解了这个函数， 上面的大家都能看懂

    * @param src
     *            源数据 ， 一个数组 
     * @param srcPos
     *         源数据开始的拷贝位置  
     * @param dst
     *            目标数组
     * @param dstPos
     *        目标数据开始的放置位置 。 
     * @param length
     *           拷贝长度 。 
     */
    public static native void arraycopy(Object src, int srcPos,
        Object dst, int dstPos, int length);

其它的方法都比较简单，大家可以自行看源码。

总结下：

1.ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低
2.ArrayList不是线程安全的。
3.ArrayList中允许元素为null。