java线性表的顺序存储结构实现

/**
 * 顺序表的实现
 */
public class SeqList<T> {
    protected Object[] element; //顺序表的元素存在这个数组中
    protected int n; //顺序表元素的个数

    //构造指定长度的空表
    public SeqList(int length){
        this.element = new Object[length];
        this.n = 0;
    }

    //默认创建长度为64的空表
    public SeqList(){
        this(64);
    }

    //用数组创建
    public SeqList(T[] values){
        this(values.length);
        for(int i=0;i< values.length;i++){
            element[i] = values[i];
        }
        this.n = element.length;
    }

    //判断是否为空表
    public boolean isEmpty(){
        return this.n == 0;
    }

    //获取顺序表的长度
    public int length(){
        return this.n;
    }

    //获取第i个元素
    public T get(int index){
        if(index >= 0 && index < this.n){
            return (T) element[index];
        }else{
            return null;
        }
    }

    //设置第i个元素的值
    public void set(int index,T value){
        if(value == null){
            throw new NullPointerException("value is null");
        }

        if(index >= 0 && index < this.n){
            element[index] = value;
        }else{
            throw  new IndexOutOfBoundsException(index+"");
        }
    }

    //返回顺序表的表述字符串
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append(this.getClass().getName()).append("(");
        if(n >0){
            sb.append(element[0].toString());
        }
        for (int i=1;i< n ;i++){
            sb.append(",").append(element[i].toString());
        }
        sb.append(")");
        return sb.toString();
    }

    //将value 插入到index位置
    public void insert(int index, T value){
        if(value == null ){
            throw new NullPointerException();
        }
        if(index < 0 ){
            index = 0;
        }else if(index > this.n){
            index = this.n;
        }
        Object[] oldElement = this.element;
        if(this.n == element.length){
            element = new Object[oldElement.length*2];
            for(int i=0;i<index;i++){
                element[i] = oldElement[i];
            }
        }
        for(int i = this.n-1;i>= index;i--){
            element[i+1] = oldElement[i];
        }
        this.element[index] = value;
        this.n++;
    }

    //不指定时插入末尾
    public void insert(T value){
        this.insert(this.n,value);
    }

    //删除指定元素
    public T remove(int index){
        if(this.n >0 && index >=0 && index <this.n){
            T temp = (T)element[index];
            for(int i= index;i<this.n -1;i++){
                element[i] = element[i+1];
            }
            element[this.n-1] = null;
            this.n --;
            return temp;
        }else{
            return null;
        }
    }

    //清空顺序表（数组实体没有释放）
    public void clear(){
        this.n =0;
    }

    //查找指定元素,并返回首次出现的序号，没有找到返回-1
    public int search(T value){
        if(value == null){
            throw new NullPointerException("value is null");
        }else{
            for (int i=0;i<this.n-1;i++){
                if(value.equals(element[i])){
                    return i;
                }
            }
            return -1;
        }
    }

    //判断value是否在顺序表中
    public boolean contains(T value){
        return search(value)!= -1;
    }

    //浅拷贝
/*    public SeqList(SeqList<T> list){
        this.n = list.n;
        this.element = list.element;
    }*/

    //深拷贝，泛型类不支持深拷贝
/*    public SeqList(SeqList<? extends T> list){
        this.n = list.n;
        this.element = new Object[list.element.length];
        for (int i=0;i< element.length ;i++) {
            this.element[i] = list.element[i];
        }
    }*/
}