数据结构之数组

public class Array {
    private int[] array;
    private int size;

    /**
     * 构造函数初始化数组
     * @param capipity
     */
    public  Array(int capipity){
        array = new int[capipity];
        size = 0;
    }

    /**
     * 默认构造函数数组容量为10
     */
     public Array(){
        this(10);
     }
    /**
     * 获取数组的总容量
     * @return
     */
    public int getCapatity(){
        return array.length;
    }
    //判断数组是否为空

    public boolean isEmpty(){
        return array.length ==0;

    }
    //获取数组元素的个数
   public int getSize(){
        return size;
   }

    /**
     * 像数组所有元素后添加一个新元素
     * @param e
     */
    public void addLast(int e){
      add(size,e);
    }

    /**
     * 向数组中第一个元素添加数据
     * @param e
     */
    public void addFirst(int e){
        add(0,e);


    }
    //像数组中任意一个位置添加元素
    public void add(int index,int e){
        if (size==array.length){
            throw new IllegalArgumentException("以达到数组最大长度，不能在添加");

        }
        if(index<0 || index> size){
            throw new IllegalArgumentException("索引异常,不合法的插入");
        }

        for (int i = size -1; i >=index;i--){
            if (i>=index){
                array[i+1] = array[i];

            }


        }
        array[index] = e;
        size++;
    }
    //获取index位置上的元素
    public int get(int index){
        if(index <0 || index>=size){
            throw new IllegalArgumentException("索引异常");
        }
        return array[index];

    }
    public void set(int index,int e){
        if(index <0 || index>=size){
            throw new IllegalArgumentException("索引异常");
        }
        array[index] =e;
    }

//判断数组是否包含元素ｅ
    public boolean Cotain(int e){

        for(int i = 0;i<size ;i++){
            if(array[i]==e){
                return true;
            }

        }
        return false;
    }

//查找数组元素ｅ的索引，如果存在元素ｅ则返回索引，否则返回－１
    public int find(int e){
        for(int i = 0;i<size;i++){
            if(array[i]==e){
                return  i;
            }
        }//当循环结束的时候，如果没有返回－１


        return -1;
    }
  //从数组中删除索引为index的元素，并將元素返回出來
    public int remove(int index){
         if(index<0 || index>=size){
             throw new IllegalArgumentException("索引异常");
         }
          for(int i=index+1;i<size;i++){
              array[i-1] = array[i];
          }
          size--;
          int e = 0;
          return   e= array[index];

    }
    //刪除第一個元素
    public int removefirst(){
        return remove(0);


    }
   //删除最后一个元素
    public int removelast(){
       return  remove(size-1);

    }
    public int deleteElete(int e){
       int index =  find(e);
        return remove(index);
    }


    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d   capatity =%d\n", size,array.length));
        res.append("[");
            for (int i = 0; i<size;i++){
                res.append(array[i]);
                if (i!=size-1){
                    res.append(",");
                }

            }
           res.append("]");
         return res.toString();
    }

} 

测试：

public class Main {

    public static void main(String [] args){
       Array   arr= new Array(20);
       for(int  i = 0 ;i<10;i++) {
           arr.addLast(i);
       }
       System.out.println(arr);
       arr.addFirst(-1);
       System.out.println(arr);
       System.out.println(arr.isEmpty());
       System.out.println(arr.get(2));
        arr.set(0,199);
       System.out.println(arr);
      int i = arr.get(3);
       System.out.println(i);
       System.out.println( arr.removefirst());
       System.out.println( arr.remove(3));
       System.out.println(arr);
       arr.removelast();
        System.out.println(arr);
        arr.remove(3);
        System.out.println(arr);
        arr.remove(0);
        System.out.println(arr);
        arr.remove(1);
        System.out.println(arr);
        arr.remove(0);
        System.out.println(arr);
        arr.deleteElete(6);
        System.out.println(arr);
        arr.add(0,12);
        System.out.println(arr);

    }
}

 结果：