顺序表的实现

/**
*线性表接口
*和存储结构无关
*/
public interface List{
       //返回线性表的大小，即数据元素的个数
       public int size();
       
       //返回线性表中序号为i的数据元素
       public Object get(int i);
       
       //如果线性表为空返回true，否则返回false
       public boolean isEmplty();
       
       //判断线性表是否包含数据元素e
       public boolean contains(Object e);
       
       //返回数据元素e在线性表中的序号
       public int indexOf(Object e);
       
       //将数据元素e插入到线性表中i号位置
       public void add(int i, Object e);
       
       //将数据元素e插入到线性表末尾
       public void add(Object e);
       
       //将数据元素e插入到元素obj之前
       public boolean addBefore(Object obj, Object e);
       
       //将数据元素e插入到元素obj之后
       public boolean addAfter(Object obj, Object e);
       
       //删除线性表中序号为i的元素，并返回
       public Object remove(int i);
       
       //删除线性表中第一个与e相同的元素
       public boolean remove(Object e);
       
       //替换线性表中序号为i的数据称元素为e，返回原数据元素
       public Object replace(int i, Object e);
}

/**
*顺序表
*底层采用的数组，但是长度可以动态变化
**/
public class ArrayList implements List{
         private Object[] elementData;  //底层是一个数组，目前还没有确定长度
         private int size; //不是数组分配了几个空间，而是元素的个数
         
         
         public ArrayList(){  
              //没有指定长度，默认长度是4
              this(4);
              //没有指定长度，长度是0，一开始放元素就需要扩容
              //elementData = new Object[]{};
         }
         
         /**
         *  initialCapacity  指定数组的初始长度
         **/
         public ArrayList(int initialCapacity){  
              //给数组分配指定数量的空间
              elementData = new Object[initialCapacity];
              //指定顺序表的元素个数，默认是0
              // size=0;
         }
         
         public void add(Object e){
             this.add(size,e);
            /*   if(size==elementData.length){
                   grow();
                }
               //给数组赋值
               elementData[size] = e;
               //元素个数+1
               size++;
               //可以合并成element[size++] = e;
               */
         }
         
         private void grow(){
             //扩容条件：数组满了
                //扩容策略：增长一倍，增长一半
                //扩容步骤
                
                    //新创建一个新的数组，长度是旧数组2倍
                    Object[] newArr = new Object[elementData.length*2]
                   /* //将旧数组的数据拷贝到新数组
                    for(int i=0;i<size;i++){
                         newArr[i] = elementData[i];
                    }
                    //让elementData指向新数组
                    elementData = newArr;*/
                    elementData = Arrays.copyOf(elementData, elementData.length*2);
         }
         
         public int size(){
              return size;
         }
         
         public boolean isEmpty(){
               return size==0;
         }
         
         public Object get(int i){
                if(i<0 || i>=size){
                     // throw new RuntimeException("数组索引越界异常："+i);
                      throw new MyArrayIndexOutOfBoundsException("数组索引越界异常："+i);
                }
                return elementData[i];
         }
         
         public void add(int i, Object e){
            //i的位置要正确
            if(i<0 || i>size){
                 throw new MyArrayIndexOutOfBoundsException("数组指针越界异常："+i)
            }
            if(size==elementData.length){
                grow();
            }
            //后移i及其后面元素，从最后一个元素开始
            for(int j= size;j >i;j--){
                   elementData[j]=elementData[j-1];
            }
            //给数组第i个位置赋值
            elementData[i]=e;
         }
         
         public String toString(){
             if(size == 0){
                return "[]";
             }
             StringBuilder builder = new StringBuilder("[");
             for(int i=0;i<size;i++){
                if(i!=size-1){
                      builder.append(elementData[i]+",");
                }else{
                      builder.append(elementData[i]);
                }
                 
             }
             builder.append("]");
             return builder.toString();
           }
             

        
}

/**
*自定义异常
**/
public class MyArrayIndexOutOfBoundsException extends RuntimeException{
       public MyArrayIndexOutOfBoundsException(){
            super();
       }
       
       public MyArrayIndexOutOfBoundsException(String message){
             super(message);
       }
}