Java ArrayList的模拟实现

package test;

import java.util.Arrays;
import java.util.Collection;

public class MyArrayList<E> {

    //存储数据
    private Object[] values;

    //已经使用的容量
    private int size;

    //修改次数
    private int modCount;

    /**
     * 根据给定容量初始化
     * @param initialCapacity
     */
    public MyArrayList(int initialCapacity){
        if(initialCapacity > ){//按照给定的容量大小初始化数组
            values = new Object[initialCapacity];
        }else if(initialCapacity == ){
            values = new Object[]{};
        }else{
            throw new IllegalArgumentException("非法初始化容量: "+
                    initialCapacity);
        }

    }

    /**
     * 默认初始化方法
     */
    public MyArrayList(){
        this();
    }

    /**
     * 用集合初始化一个ArrayList
     * @param c
     */
    public MyArrayList(Collection c){
        values = c.toArray();
        if (values.length != ) {
            size = values.length;
            if (values.getClass() != Object[].class)
                values = Arrays.copyOf(values, size, Object[].class);
        }else{
            values = new Object[]{};
        }
    }
    /**
     * 检查是否数组越界了
     * @param index
     */
    private void rangeCheck(int index) {
        if (index >= size || index < )
            throw new IndexOutOfBoundsException("数组越界了");
    }

    /**
     * 替换原数组中的值，并且将原值返回
     * @param index
     * @param element
     * @return
     */
    public E set(int index,E element){
        //检查是否越界
        rangeCheck(index);

        E oldValue = (E)values[index];
        values[index] = element;

        return oldValue;
    }

    /**
     * 在数组的末尾增加一个元素
     * @param element
     */
    public void add(E element){
        //扩容
        ensureCapacity(size+);
        values[size++] = element;

    }

    /**
     * @param index
     * @param element
     */
    public void add(int index,E element){
        //先检查数组的下标是否越界了
        rangeCheck(index);
        //扩容
        ensureCapacity(size+);

        Object[] oldValues = values;
        values[index] = element;

        //将原数组index后的值拷贝带新数组中
        System.arraycopy(oldValues, index, values, index+, size-index);

        size++;

    }

    /**
     * 将一个collection中的元素添加到数组末尾
     * @param c
     */
    public void addAll(Collection c){
        Object[] cArray = c.toArray();

        //扩容
        ensureCapacity(size+cArray.length);

        //将传入数据拷贝到数组末尾
        System.arraycopy(cArray, , values, size, cArray.length);

        size += cArray.length;
    }

    /**
     * 将一个collection中的元素添加到数组的指定位置
     * @param index
     * @param c
     */
    public void addAll(int index,Collection c){
        //先检查数组的下标是否越界了
        rangeCheck(index);
        //扩容
        Object[] cArray = c.toArray();
        int cLength = cArray.length;

        ensureCapacity(size+cLength);

        Object[] oldValues = values;
        //将传入数据拷贝到数组指定位置
        System.arraycopy(cArray, , values, index, cLength);

        //将原数组中index以后的数据拷贝过来
        System.arraycopy(oldValues, index, values, values.length-, size-index);

        size += cLength;

    }

    /**
     * 根据下标获取元素
     * @param index
     * @return
     */
    public E get(int index){
        //先检查数组的下标是否越界了
        rangeCheck(index);

        E e = (E) values[index];

        return e;

    }

    /**
     * 根据下标删除元素
     * @param index
     * @return
     */
    public E remove(int index){
        //先检查数组的下标是否越界了
        rangeCheck(index);

        E removeValue = (E) values[index];

        System.arraycopy(values, index+, values, index, size-index-);

        //置为空，gc回收
        values[size--] = null;

        return removeValue;

    }

    /**
     * 根据对象删除
     * @param o
     */
    public void remove(Object o){
        //考虑元素为null的情况
        if(null == o){
            for (int i = ; i < size; i++) {
                if(values[i] == null){
                    remove(i);
                }
            }

        }else{
            for (int i = ; i < size; i++) {
                if(values[i].equals(o)){
                    remove(i);
                }
            }

        }
    }

    /**
     * 扩容方法，保证数组的长度足够
     * @param minCapacity
     */
    public void ensureCapacity(int minCapacity){
        modCount++;

        int oldCapacity = values.length;
        if (minCapacity > oldCapacity) {
            //先默认扩容50%+1，如果还是不能满足，则直接用传入的所需容量
            int newCapacity = (oldCapacity*)/+;
            if(newCapacity < minCapacity){
                newCapacity = minCapacity;
            }

            values = Arrays.copyOf(values, newCapacity);

        }
    }

    public int size(){
        return size;
    }

}

最后再介绍一下ensureCapacity这个方法的想法（从网上看到的）：

我们知道ArrayList的内部是采用数组来存储元素的，由于java数组都是定长的，所以这个数组的大小一定是固定的，这个大小就是capacity。我们可以肯定capacity一定是大于或等于ArrayList的size，那么当size不断增加到了要超过capacity的时候，ArrayList就不得不重新创建新的capacity来容纳更多的元素，这时需要首先建立一个更长的数组，将原来的数组中的元素复制到新数组中，再删除原来的数组。可见当ArrayList越来越大时，这种操作的消耗也是越来越大的。
为了减少这种不必要的重建capacity的操作，当我们能肯定ArrayList大致有多大（或者至少会有多大）时，我们可以先让ArrayList把capacity设为我们期望的大小，以避免多余的数组重建。
假设ArrayList自动把capacity设为10，每次重建时将长度递增原来的三分之二，那么当我们需要大约存储50个元素到ArrayList中时，就会大约需要重建数组4次，分别是在增加第11、第17、第26、第39个元素的时候进行的。如果我们一开始就让ArrayList的capacity为50，那么不需要任何数组重建就能完成所有插入操作了。
java允许我们在构造ArrayList的同时指定capacity，如new ArrayList(50)，也允许在以后将它设得更大，而增大capacity就是使用ensureCapacity()方法。注意：capacity只能比原来的更大，而不能比原来的更小，否则java会忽略该操作。ArrayList的初始默认capacity为10，所以给capacity指定小于10的整数是毫无意义的。
最后说说ArrayList的size，前面说过，size一定小于等于capactiy，而且更重要的是，访问超过size的位置将抛出异常，尽管这个位置可能没有超过capacity。ensureCapacity()只可能增加capacity，而不会对size有任何影响。要增加size，只能用add()方法。