/**
 * Created with IntelliJ IDEA.
 * CreateUser:  blentle
 * Email: renhuan@milipp.com
 * CreateTime:  2014/11/6 12:40
 * ModifyUser:  blentle
 * ModifyTime:  2014/11/6 12:40
 * Class Description:
 * To change this template use File | Settings | File Templates.
 */
public class SequenceList<T> {
    //不指定存储空间时的默认存储，操作时越界暂时将抛出异常
    private static final int DEFAULT_CAPACITY = 10;
    //线性表的最大长度（数组的长度）
    private int capacity;
    //线性表元素的个数
    private int size;
    //存储线性表元素的数组
    private Object[] elementData;

    /**
     * 使用默认的最大存储空间，超过最大存储空间将抛出异常
     */
    public SequenceList() {
        this(DEFAULT_CAPACITY);
    }

    /**
     *
     * @param initialCapacity 最大存储空间初始化
     */
    public SequenceList(int initialCapacity) {
        this.capacity = initialCapacity;
        this.elementData = new Object[capacity];
    }

    /**
     *
     * @return 线性表的长度
     */
    public int size() {
        return this.size;
    }

    /**
     *
     * @return 线性表是否是空表
     */
    public boolean isEmpty() {
        return this.size == 0;
    }

    /**
     * 获取元素
     * @param index
     * @return T
     */
    public T get(int index) {
        //检查序号是否越界,注意inde是从0开始
        if(index >= size) {
            throw new IndexOutOfBoundsException("index is :"+ index + "but size is:" + this.size);
        }
        return elementData(index);
    }

    public boolean add(int index,T element) {
        //检查序号是否越界,注意inde是从0开始,最大值是size-1
        if(index > size || index < 0) {
            throw new IndexOutOfBoundsException("index is :"+ index + ",but size is:" + this.size);
        }
        //若链表已满(元素个数等于数组初始化最大容量，一般ArrayList继续扩展容量，这里抛出异常)
        if(size == capacity) {
            throw new IndexOutOfBoundsException("list is full...");
        }
        if(index == size) {
            //插在表尾
            elementData[size] = element;
        } else {
            //插在其他地方，index后面的的每一个元素向后挪一位
            for(int i = size + 1 ; i > index ; i--) {
                elementData[i] = elementData[i-1];
            }
        }
        //index位置被替换成element
        elementData[index] = element;
        size++;
        return true;
    }

    /**
     * 不指定插入位置，插入表尾
     * @param t 链表元素
     * @return
     */
    public boolean add(T t) {
        return add(size,t);
    }

    /**
     * 从表中移除元素
     * @param index 元素序号
     * @return
     */
    public boolean remove(int index) {
        if(index >= size || index < 0) {
            throw new IndexOutOfBoundsException("index is :"+ index + ",but size is:" + this.size);
        }
        for(int k = index ; k < size - 1 ; k++) {
            elementData[k] = elementData[k + 1];
        }
        elementData[size - 1] = null;
        size--;
        return true;
    }

    /**
     * 清空线性表
     */
    public void clear() {
        if(size > 0) {
            for(int i = 0 ; i < size ; i ++) {
                elementData[i] = null;
            }
            size = 0;
        }
    }

    @Override
    public String toString() {
        String a = "";
        for(int i = 0 ; i < size() ; i ++) {
            a += (T)elementData[i] + " ";
        }
        return a;
    }

    /**
     * 获取元素并强制转换的封装（参考ArrayList源码）
     * @param index
     * @return
     */
    private T elementData(int index) {
        return (T) elementData[index];
    }
}