Java手动实现有序表

public class SequenceList<E> {

    /**
     * 有序表
     */
    private Object[] list;

    /**
     * 默认容量
     */
    private int defaultCapatity = 10;

    /**
     * 有序表长度
     */
    private int length;

    /**
     * 当前容量
     */
    private int size;

    /**
     * 以默认容量有序表
     */
    private void init(){
        list = new Object[defaultCapatity];
        length = defaultCapatity;
        size = 0;
    }

    /**
     * 以指定容量初始化有序表
     * @param capatity
     */
    private void init(int capatity){
        list = new Object[capatity];
        length = capatity;
        size = 0;
    }

    public SequenceList(){
        this.init();
    }

    public SequenceList(int capatity){
        this.init(capatity);
    }

    /**
     * 在有序表末尾追加元素
     * @param element
     * @return
     */
    public int add(E element){

        return this.add(size , element);
    }

    // 在指定位置（index<size）插入元素
    public int add(int index, E element){
        // 超出范围时，先不对有序表做动态扩容，抛出异常
        if(index<0  || index>size){
            throw new RuntimeException("超出有序表范围！");
        }

        grow();

        // 将插入位置之后的元素全部后移1位
        for(int i=length-1 ; i>index ; i--){
            list[i] = list[i-1];
        }
        list[index] = element;
        size++;
        return index;
    }

    // 删除有序表中指定位置的元素
    public Object remove(int index){
        if(index<0 || index>=size){
            throw new RuntimeException("超出有序表范围！");
        }
        Object element = list[index];
        // 将删除位置之后的元素前移一位
        for(int i=index ; i<size-1 ; i++){
            list[i] = list[i+1];
        }
        list[size-1] = null;
        size--;
        return element;
    }

    // 返回元素在有序表中第一次出现的索引
    public int index(E element){
        if(null == element){
            return -1;
        }
        for(int i=0 ; i<list.length ; i++){
            if(element.equals(list[i])){
                return i;
            }
        }
        return -1;
    }

    // 判断元素在有序表中是否存在
    public boolean contains(E element){
        return index(element)==-1? false : true;
    }

    // 返回有序表的容量
    public int length(){
        return this.list.length;
    }
    // 返回有序表当前所有元素个数
    public int size(){
        return this.size;
    }

    // 有序表扩容
    private void grow(){
        if(size<length){
            return;
        }
        Object[] originalList = list;
        list = new Object[length*2];
        System.arraycopy(originalList,0,list,0,length);
        length = length*2;
    }
}