Java实现顺序表

利用顺序存储结构表示的顺序表称为顺序表。

　　它用一组连续的地址存储单元一次存放线性表中的数据元素。

顺序表的实现是数据结构中最简单的一种。

由于代码中已经有详细注释，代码外不再阐述。

下次再陈上关于顺序表的循环队列和顺序栈的代码。

package 线性表.顺序表.普通数组;

/**
 * ArrayList 顺序表
 * JAVA 3.0
 * 抛异常处理错误的下标
 * 使用泛型,当然如果要替换成Object也是可以替换
 */
public class ArrayList<E> {

    private int capacity; //数组的总容量
    private int current;  //当前最后一个数组元素的下一个元素下标，从0开始，也是长度
    private E[] data = null; //所有数据
    
    public ArrayList(){
        
        this(10);
    }
    
    public ArrayList(int initialSize){
        
        init(initialSize);
    }
    /**
     * 初始化数组
     */
    @SuppressWarnings("unchecked")
    public void init(int initialSize){
        
        current = 0;
        data = (E[])new Object[initialSize];  
        capacity = initialSize;
    }
    /**
     * 数组末尾插入元素*/
    public void add(E e){
        
        ensureCapacity();
        data[current] = e;
        current++;
        
    }
    /**
     * 在数组中插入元素*/
    public void insert(int index, E e){
        
        validateIndex(index);
        ensureCapacity();
        for(int i=current;i>=index;i--){
            
            data[i+1] = data[i];
        }
        data[index] = e;
        current++;
    }
    /**
     * 判断是否需要扩展数组
     * 如果需要将扩展为原来的两倍
     */
    @SuppressWarnings("unchecked")
    private void ensureCapacity(){
        
        if(current == capacity){
                    
            capacity = capacity * 2;
            E[] newData = (E[])new Object[capacity];  
            for(int index = 0; index < current; ++index) {  
                newData[index] = data[index];  
            }  
            data = newData;
        }
    }
    
    /**
     * 删除某个已经存在的对象
     * 如果T在数组中，则删除成功返回true，否则无这个元素返回false
     */
    public boolean remove(E e){
        
        for(int i=0;i<current;i++){
            
            if(data[i].equals(e)){
                
                remove(i);
                return true;
            }
        }
        return false;
    }
    /**
     * 删除特定下标的数组
     * @param index
     */
    public void remove(int index){
        
        validateIndex(index);
        for(int i=index;i<current;i++){
            
            data[i] = data[i+1];
        }
        data[current] = null;
        current--;
    }
    /**
     * 修改下标为index的值*/
    public void set(int index, E e){
        
        validateIndex(index);
        data[index] = e;
    }
    /**
     * 获取下标为index的值
     */
    public E get(int index){
        
        validateIndex(index);
        return data[index];
    }
    /**
     * 获取数组已使用的个数
     */
    public int size(){
        
        return current;
    }
    /**
     * 销毁数组所有元素
     */
    public void clear(){
        
//      Arrays.fill(data, null);  可以替代下面的for循环
        for(int i=0;i<current;i++){
            
            data[i] = null;
        }
        capacity = 0;
        current = 0;
    }
    /**
     * 判断数组是否为空
     */
    public boolean isEmpty(){
        
        return current==0;
    }
    /**
     * 打印结构
     */
    public String toString() {  
        
        String str = "[ ";  
        for (Object o : data) {  
            if (o != null) {  
                str += o + " ";  
            }  
        }  
        str += "]";  
        return str;  
    }  
    /** 　　 * 判断index 是否越界　　 */
    private void validateIndex(int index) {  
        
        if (index < 0 || index >= current) {  
            throw new IndexOutOfBoundsException("无效的下标：" + index);  
        }  
    }