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 > 0){//按照给定的容量大小初始化数组
            values = new Object[initialCapacity];
        }else if(initialCapacity == 0){
            values = new Object[]{};
        }else{
            throw new IllegalArgumentException("非法初始化容量: "+
                    initialCapacity);
        }

    }
    
    /**
     * 默认初始化方法
     */
    public MyArrayList(){
        this(10);
    }
    
    /**
     * 用集合初始化一个ArrayList
     * @param c
     */
    public MyArrayList(Collection c){
        values = c.toArray();
        if (values.length != 0) {
            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 < 0)
            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+1);
        values[size++] = element;
        
    }
    
    /**
     * @param index
     * @param element
     */
    public void add(int index,E element){
        //先检查数组的下标是否越界了
        rangeCheck(index);
        //扩容
        ensureCapacity(size+1);
        
        Object[] oldValues = values;
        values[index] = element;
        
        //将原数组index后的值拷贝带新数组中
        System.arraycopy(oldValues, index, values, index+1, size-index);
        
        size++;
        
    }
    
    /**
     * 将一个collection中的元素添加到数组末尾
     * @param c
     */
    public void addAll(Collection c){
        Object[] cArray = c.toArray();
        
        //扩容
        ensureCapacity(size+cArray.length);
        
        //将传入数据拷贝到数组末尾
        System.arraycopy(cArray, 0, 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, 0, values, index, cLength);
        
        //将原数组中index以后的数据拷贝过来
        System.arraycopy(oldValues, index, values, values.length-1, 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+1, values, index, size-index-1);
        
        //置为空，gc回收
        values[size--] = null;
        
        return removeValue;
        
    }
    
    /**
     * 根据对象删除
     * @param o
     */
    public void remove(Object o){
        //考虑元素为null的情况
        if(null == o){
            for (int i = 0; i < size; i++) {
                if(values[i] == null){
                    remove(i);
                }
            }
            
        }else{
            for (int i = 0; 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*3)/2+1;
            if(newCapacity < minCapacity){
                newCapacity = minCapacity;
            }
            
            values = Arrays.copyOf(values, newCapacity);
            
        }
    }
    
    public int size(){
        return size;
    }

    

}