ArrayList

初始化过程

构造器

    /**     * Constructs an empty list with an initial capacity of ten.     */    public ArrayList() {        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }     transient Object[] elementData; // non-private to simplify nested class access     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

可见默认ArrayList底层是数组结构，初始化时构建一个空数组，DEFAULTCAPACITY_EMPTY_ELEMENTDATA由static修饰，可以看成是存在方法区的缓存数组，可以避免new时创建无数的无用数组。

元素增删

---

扩容与add()方法

    private int size; //The size of the ArrayList (the number of elements it contains).    private static final int DEFAULT_CAPACITY = 10;    /**     * Appends the specified element to the end of this list.     */    public boolean add(E e) {        ensureCapacityInternal(size + 1);  // Increments modCount!!        elementData[size++] = e;  //数组初始化后添加元素，并让长度自增        return true;    }     private void ensureCapacityInternal(int minCapacity) {        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }  //如果底层数组是默认数组就取两个参数的大值        ensureExplicitCapacity(minCapacity);    }    private void ensureExplicitCapacity(int minCapacity) {        modCount++;  //修改次数        // overflow-conscious code        if (minCapacity - elementData.length > 0)  //判断参数是否大于底层数组长度            grow(minCapacity);  //扩容方法    }    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;    /**      * 计算扩容后的数组长度， 然后调用copyOf()方法      */     private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1);  //1.5倍扩容        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);    }    //数组复制方法     public static <T> T[] copyOf(T[] original, int newLength) {        return (T[]) copyOf(original, newLength, original.getClass());    }     public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {        @SuppressWarnings("unchecked")        T[] copy = ((Object)newType == (Object)Object[].class)            ? (T[]) new Object[newLength]  //创建一个数组，长度由之前方法传入            : (T[]) Array.newInstance(newType.getComponentType(), newLength);        System.arraycopy(original, 0, copy, 0,                         Math.min(original.length, newLength));  //复制数组的本地方法        return copy;    }

总结一下ArrayList添加过程：
1.设置新长度为size + 1。
2.如果底层是默认缓存数组，设置新长度值为默认长度。
3.如果新长度值大于底层数组长度，调用扩容方法，modCount++。
4.计算扩容后的数组长度。
5.创建一个新数组，并复制原数组的数据，返回新数组。（通常扩容1.5倍）

创建ArrayList时选取合适的初始大小可以减少扩容次数，减少底层数组的复制次数，从而提高性能。

删除元素remove（）方法

---

ArrayList删除某个元素时会把它后面的元素复制到前一格去，然后删除掉最后一节点的元素使其为null。
是复制不是移动，因此复制完成后最后两个元素指向同一个对象。
最后一节点的元素由于失去引用，会在下次GC到来时被JVM回收。
这样可以避免ArrayList中间有一格null元素。
因此，过多的删除操作会造成数组的大量复制工作，时间复杂度为O(n)，此时应考虑使用LinkedList链表结构。

根据下标删除

public E remove(int index) {    rangeCheck(index);  //检查下标是否越界并报错的方法，不代码贴了。    modCount++;    E oldValue = elementData(index);    int numMoved = size - index -1; //要移动的元素数量    if (numMoved > 0)        System.arraycopu(elementData, index + 1, elementData, index, numMoved);    elementData[--size] = null //最后一个元素置空    return oldValue;}

根据元素Object删除

    public boolean remove(Object o) {        if(o == null) {  //要删除的元素为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])) {   //调用了要删除元素的equals()方法                    fastRemove(index);                    return true;                }        }        return false;    }    /*     * Private remove method that skips bounds checking and does not     * return the value removed.     */     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    }

可以看到根据元素Object来删除ArrayList里的元素时会调用要删除元素的equals( )方法，因此，在ArrayList里存储对象时可能需要重写equals( )来使业务逻辑正确执行。（不重写时equals默认使用继承自Object类的 == 逻辑） 而重写equals( )后又要重写hashCode方法，所以不建议使用这个方法。

元素读取

---

    public E get(int index) {        rangeCheck(index);        return elementData(index);    }    public E set(int index, E element) {         rangeCheck(index);        E oldValue = elementData(index);        elementData[index] = element;        return oldValue;    }

读/取方法比较简单。

复杂度

---

可见ArrayList的元素读/取都是通过底层数组下标直接定位的，复杂度O(1)。
增删操作在不触发数组复制时复杂度O(1)，否则为O(n)。

会造成底层数组复制的操作：
-增：扩容（添加元素时底层数组长度不够）
-删：不是最后一个元素的删除操作