1.陣列優勢

（1）快速查詢

（2）適用於有語境的情況

2.製作私有陣列

（1）使用泛型，從而可以實現儲存多種型別資料

（2）可以動態擴容或者縮容

（3）實現增刪改查基本操作

3.java實現

public class ArrayDynamic<E> {
    private E[] data; //陣列
    private int size; //陣列中實際元素個數
//*****************************************************************************************
    //1.建構函式
    //建構函式，傳入陣列的容量capacity
    public ArrayDynamic(int capacity){
        data=(E[])new Object[capacity];
        size=0;
    }
    //無引數建構函式，預設陣列的容量10
    public ArrayDynamic(){
        this(10);
    }

//*****************************************************************************************
    //2.獲得基本資訊操作
    //獲取陣列容量
    public int getCapacity(){
        return data.length;
    }
    //獲取陣列中的元素個數
    public int getSize(){
        return size;
    }
    //返回陣列是否為空
    public boolean isEmpty(){
        return size==0;
    }
//*****************************************************************************************
    //3.新增元素操作（增）
    /**
     * 3.1向所有元素後新增一個新元素
     * @param e
     */
    public void addLast(E e){
        if (size==data.length){
            throw new IllegalArgumentException("AddLast failed. Array is full.");

        }
        data[size] = e;
        size ++;
    }
    /**
     * 3.2在所有元素前新增一個新元素
     * @param e
     */
    public void addFirst(E e){
        add(0,e);
    }

    /**
     * 3.3在index索引位置插入一個新元素
     * @param index 索引
     * @param e 元素
     */
    public void add(int index,E e){
        if(index<0||index>size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
        }
        if(size==data.length){
            //當達到最大長度時候，實行擴容
            resize(2*data.length);
        }
        for (int i =size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }

    //將陣列容量變為newCapacity大小
    private void resize(int newCapacity){
        E[] newData=(E[])new Object[newCapacity];
        for (int i =0;i<size;i++){
            newData[i]=data[i];
        }
        data=newData;
    }
//*****************************************************************************************

    //4.查詢資料
    /**
     * 4.1獲得指定位置元素
     * @param index
     * @return
     */
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        return data[index];
    }

    /**
     * 4.2查詢是否包含元素e
     * @param e
     * @return
     */
    public boolean contains(E e){
        for (int i =0;i<size;i++){
            if(data[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    /**
     * 4.3查詢包含元素所在索引，不包含則返回-1
     * @param e
     * @return
     */
    public int find(E e){
        for (int i =0;i<size;i++){
            if (data[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 4.4 獲得最後一個
     * @return
     */
    public E getLast(){
        return get(size-1);
    }
//*****************************************************************************************

    //5.修改
    /**
     * 5.1修改指定位置元素
     * @param index
     * @param e
     */
    public void set(int index,E e){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        data[index]=e;
    }

//*****************************************************************************************
    //6.刪除
    /**
     * 6.1 從陣列中刪除元素，返回刪除元素
     * @param index
     * @return
     */
    public E remove(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        E ret=data[index];
        for (int i=index;i<size;i++){
            data[i]=data[i+1];
        }
        size--;
        data[size]=null;

        if(size == data.length / 4 && data.length / 2 != 0)
        {
            resize(data.length/2);
        }
        return ret;
    }


    /**
     * 6.2 從陣列中刪除第一個元素，返回刪除元素
     * @return
     */
    public E removeFirst(){
        return remove(0);
    }

    /**
     * 6.3 從陣列中刪除最後一個元素，返回刪除元素
     * @return
     */
    public E removeLast(){
        return remove(size-1);
    }

    /**
     * 6.4 從陣列中刪除元素e
     * @param e
     */
    public void removeElement(E e){
        int index=find(e);
        if (index!=-1){
            remove(index);
        }
    }
    //*****************************************************************************************
    @Override
    public String toString(){
        StringBuilder res=new StringBuilder();
        res.append(String.format("Array:size=%d,capacity=%d\n",size,data.length));
        res.append("[");
        for (int i =0;i<size;i++){
            res.append(data[i]);
            if(i!=size-1){
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }

}