ArrayList源码总结

1.构造函数

1.1无参数构造函数

public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
}
private static final Object[] EMPTY_ELEMENTDATA = {};

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == 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 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);
    }
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

总结：1.7以前的版本默认初始化为10的容量，但在1.7版本是需要扩容的，也是扩容容量为10，但是有一个数组copy的过程

1.2传入容量的构造函数

public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

总结：和以前版本一样，传入初始化容量大小

1.3传入集合的构造函数

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);
    }

总结：c.toArray()是方法中重新创建一个数组返回

2.扩容

    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);
    }

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

注：2.1容量够就不需要扩容，直接放入数组

2.2容量不够就需要扩容原始容量1.5倍+1

2.3假如容量还不够,传入值就是扩容的值

2.4假如扩容的值 比 MAX_ARRAY_SIZE 大，扩容值就是Integer.MAX_VALUE 否则MAX_ARRAY_SIZE；

2.5最大扩容值 就是 Integer.MAX_VALUE
 

3.数组copy的方式（属于浅复制）

   3.1 Arrays.copyof()和System.arraycopy()

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) {
        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;
    }

Arrays.copyof()方法，它有很多个重载的方法，但实现思路都是一样的
该方法实际上是在其内部又创建了一个长度为newlength的数组，调用System.arraycopy()方法是native方法，将原来数组中的元素复制到了新的数组中

属于浅复制

4.Arraylist的2个toArray()方法

    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

注:大致相同，底层都是使用copy到一个新的数组，唯一不同的就是返回的类型

Toarray(T[] a) 返回的可以整体向下转型，toArray()不可以。

5.clone

public Object clone() {
        try {
            @SuppressWarnings("unchecked")
                ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

注：使用copyof copy数据，所以浅复制

5、ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低。

6、在查找给定元素索引值等的方法中，源码都将该元素的值分为null和不为null两种情况处理，ArrayList中允许元素为null。

7.add(索引，值) 和 addall(索引，值)

流程：首先判断是否需要扩容，需要的话就copy一个新的数组，然后判断是直接放在数组的为后面添加，还是在中间添加，所以中间添加的话涉及到数组的移动。添加在数组的尾端不涉及到数组的移动

8.remove 

流程：假如删除的数据的索引实在尾部，不涉及到数据的移动，只需要删除数据，假如是在中间就需要涉及到数据的移动