public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    /**

     * 默认容量值

     */

    private static final int DEFAULT_CAPACITY = 10;

    /**

     * 默认容量为空的数组

     */

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**

     * 用来存储元素

     */

    transient Object[] elementData;

    /**

     * 数组大小

     *

     * @serial

     */

    private int size;

    /**

     * 添加元素

     *

     * @param e

     * @return

     */

    public boolean add(E e) {

        ensureCapacityInternal(size + 1);

        elementData[size++] = e;

        return true;

    }

    /**

     * 确保容量动态增长

     *

     * @param minCapacity

     */

    private void ensureCapacityInternal(int minCapacity) {

        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

        }

        ensureExplicitCapacity(minCapacity);

    }

    /**

     * 确定新的容量

     *

     * @param 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;

    /**

     * 数组容量动态增长

     *

     */

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

    }

    /**

     * 计算数组最终容量

     *

     * @param minCapacity

     * @return

     */

    private static int hugeCapacity(int minCapacity) {

        if (minCapacity < 0) // overflow

            throw new OutOfMemoryError();

        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;

    }

}

    @SuppressWarnings("unchecked")

    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;

    }

   public static native void arraycopy(Object src,  int  srcPos,

                                        Object dest, int destPos,

                                        int length);