transient Object[] elementData; // 用于存放元素的数据，数组的大小就是ArrayList的容量capacity

private int size;//数组中已经存放的元素的数量

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 确保elementData数组中还有空间插入新的元素
    elementData[size++] = e;//在数组的最后一个插入元素
    return true;
}

private void grow(int minCapacity) {//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)//这个用于保证数组的容量最大不会超过2的30次方-1
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    //使用计算出需要扩大到的新的容量创建一个新数组，并将elementData[]的数组中元素拷贝到新的数组中，再重新赋值给elementData[]。
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public E remove(int index) {
    rangeCheck(index);
 
    modCount++;
    E oldValue = elementData(index);//获取要删除的元素的值
   //因为删除一个元素之后，要将后继的元素往前移动一个位置，所以计算从哪个位置开始移动
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);//移动元素
    elementData[--size] = null; //删除size位置上的元素，同时将size-1，再将这个位置上的元素置为null以便垃圾回收
 
    return oldValue;//返回删除的元素的值。
}

public int indexOf(Object o) {
    if (o == null) {//如果对象是null，返回elementData[]中第一个元素值为null的下标
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {////如果对象不是null，返回elementData[]中第一个equals方法相等的index
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;//查找不到返回-1
}

public class SimpleArrayList<T> {
    //数组中元素的大小
    private Integer element_size = 0;
    //创建SimpleArrayList时，数组的容量，默认为16
    private Integer array_capacity = 16;
    //当数组容量不够时，默认每次扩容的大小
    private static final Integer DEFUALT_EXPAND_SIZE=16;
    
    Object[] array = null;
 
    public SimpleArrayList() {
        this(DEFUALT_EXPAND_SIZE);
    }
 
    /**
     * @param array_capacity 数组大小
     */
    public SimpleArrayList(Integer array_capacity) {
        super();
        if(array_capacity<=0){
            throw new  IllegalArgumentException("array_capacity must >0");
        }
        array=new Object[array_capacity];
        this.array_capacity = array_capacity;
        
    }
    
    /**
     * 插入一个新元素，如果数组可以放下，直接添加
     * 如果数组中放不下，扩容
     * @param elememt
     */
    public void add(T elememt){
        if(element_size<array_capacity){//如果数组可以放下，直接添加
            array[element_size++]=elememt;
        }else{////如果数组放不下，扩容后再添加
            array_capacity+=DEFUALT_EXPAND_SIZE;
            Object[] new_array=new Object[array_capacity];
            System.arraycopy(array, 0, new_array, 0, array.length);
            array=new_array;
            array[element_size++]=elememt;
        }
    }
    
    /**
     * 根据指定下标查找元素
     * @param index
     * @return
     */
    @SuppressWarnings("unchecked")
    public T get(int index){
        if(index<0||index>element_size-1){
            throw new ArrayIndexOutOfBoundsException(index);
        }
        return (T) array[index];
    }
    
    /**
     * 删除指定位置的元素，所有之后的元素需要前移
     * @param index
     */
    public void remove(int index){
        if(index<0||index>element_size-1){
            throw new ArrayIndexOutOfBoundsException(index);
        }
        for (int i = index; i < element_size-1; i++) {
            array[i]=array[i+1];
        }
        element_size--;
    }
    
    /**
     * 更新指定位置上的元素
     * @param index
     * @param element
     */
    public void update(Integer index,T element){
        if(index<0||index>element_size-1){
            throw new ArrayIndexOutOfBoundsException(index);
        }
        array[index]=element;
    }
    
    /**
     * 返回array中元素的大小
     * @return
     */
    public Integer size(){
        return element_size;
    }
    
    public Integer capacity(){
        return array_capacity;
    }
}