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

package com.hongliang;

/**
 * 顺序表的实现 
 * @author KevinHong
 */
public class ArrayList
 
   {

    /**
     * 获得顺序表的容量
     * @return 顺序表的容量
     */
    public int getCapacity() {
        return capacity;
    }

    /**
     * 获得顺序表当前元素的下标
     * @return 当前元素的下标
     */
    public int getCurrent() {
        return current;
    }
    
    private Object[] data = null; //data:存放顺序表数据的数组
    private int capacity = 0;  //capacity: 顺序表的容量
    private int current = 0;  //current: 顺序表的当前元素的下标
    
    public ArrayList(){
        data = new Object[10];
    }
    
    /**
     * 初始化顺序表，声明顺序表初始化的容量
     * @param initSize 顺序表初始化的容量
     */
    public ArrayList(int initSize) {
        if(initSize >= 0) {
            data = new Object[initSize];
            this.capacity = initSize;
            this.current = 0;
        } else {
            throw new RuntimeException("初始化值错误，不允许小于0");
        }
    }
    
    /**
     * 获取顺序表的元素个数
     * @return 顺序表的元素个数
     */
    public int size() {
        return this.current;
    }
    
    /**
     * 在顺序表最后追加元素
     * @param element 需要追加的元素
     * @return 返回追加元素后，当前元素的下标 
     */
    public int append(E element) {
        ensureCapacity();
        data[this.current] = element;
        this.current++;
        return this.current;
    }
   
    /**
     * 在顺序表的指定位置插入元素
     * @param index 想要插入元素的位置
     * @param element 想要插入的元素
     * @return 返回插入元素是否成功
     */
    public boolean insert(int index, E element) {
        ensureCapacity();
        validateIndex(index);
        for(int i = this.current; i > index; i--) {
            data[i] = data[i-1];
        }
        data[index] = element;
        this.current++;
        return true;
    }
    
    /**
     * 顺序表中指定下标设置元素
     * @param index 顺序表中元素下标
     * @param element 想要设置的元素
     * @return  返回指定下标设置元素是否成功
     */
    public boolean set(int index, E element) {
        ensureCapacity();
        validateIndex(index);
        data[index] = element;
        return true;
    }
    
    /**
     * 获取顺序表中指定下标的元素
     * @param index 顺序表中指定的位置
     * @return  返回指定下标的元素
     */
    public E get(int index) {
        validateIndex(index);
        return (E)data[index];
    }
    
    /**
     * 删除顺序表中指定下标的元素
     * @param index 顺序表中指定的下标
     * @return  返回删除删除指定下标元素是否成功
     */
    public boolean delete(int index) {
        validateIndex(index);
        for(int i = index; i < this.current - 1; i++) {
            data[i] = data[i+1];
        }
        data[this.current] = null;
        this.current--;
        return true;
    }
    
    /**
     * 将顺序表转换成字符串
     * @return 转换后的字符串
     */
    public String toString() {
        String toString = "[";
        for(int i = 0; i < size(); i++) {
            if(i != size() - 1) {
                toString += data[i] + "," ;
            } else {
                toString += data[i] + "";
            }
        }
        toString += "]";
        return toString;
    }
    
    /**
     * 检查存储数据的数组容量，如果数组已经满，则扩充容量；否则不操作。 
     */
    private void ensureCapacity() {
        if(this.current == this.capacity) {
            this.capacity *= 2;
            Object[] newData = new Object[this.capacity];
            for(int i = 0; i < this.current; i++) {
                newData[i] = data[i];
            }
            data = newData;
        }
    }
    
    /** 
     * 验证下标值是否合法，非法时抛出异常 
     * @param index 待验证的下标值 
     */  
    private void validateIndex(int index) {
        if(index < 0 || index > this.current) {
            throw new RuntimeException("不是合法的下标");
        }
    }
}