1.新增方法要擴容，陣列是沒有擴容機制的。

2.刪除方法要重新排元素，將後面的元素向前推。

package demo1;
/**
 * 線性表(列表)的介面
 * @author DeepSleeping
 *
 */
public interface MyList {

    /*新增一個元素*/
    void add(Object element);
    /*刪除相同元素*/
    void delete(Object element);
    /*根據索引刪除元素*/
    void delete(int index);
    
 
/*將指定索引位置的元素替換成新元素*/
    void update(int index,Object newElement);
    /*當前列表中是否含有target這個元素*/
    boolean contains(Object target);
    /*返回指定索引處的元素*/
    Object at(int index);
    /*查詢element的索引,如果沒有返回-1*/
    int indexOf(Object element);
    
}

package demo1;

/**
 * 用順序儲存(陣列)方式來實現列表
 * 
 * @author DeepSleeping
 *
 
 
*/
public class MyArrayList implements MyList {

    private Object[] elements;// 真正儲存元素的底層結構
    private int size = 0;// 元素的個數
    private int capacity = 10;// 容量

    public MyArrayList(int capacity) {
        this.capacity = capacity;
        elements = new Object[capacity];
    }

    @Override
    public
 
 String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            sb.append(elements[i] + (i == size - 1 ? "" : ","));
        }
        sb.append("]");
        return sb.toString();
    }

    public MyArrayList() {
        elements = new Object[capacity];
    }

    /**
     * 新增一個元素
     * @param element
     */
    @Override
    public void add(Object element) {
        if (size == capacity) { // 擴容
            capacity *= 2; // 增加一倍的容量
            Object[] newArr = new Object[capacity];// 新建一個數組
            for (int i = 0; i < size; i++) {
                newArr[i] = elements[i];
            }
            elements = newArr; // 把舊的那個櫃子扔掉
        }
        elements[size++] = element;
    }

    /**
     * 刪除相同元素
     * @param element
     */
    @Override
    public void delete(Object element) {
        int index = indexOf(element);
        if (index >= 0) {
            delete(index);
        }
    }

    /**
     * 根據索引刪除元素
     * @param index
     */
    @Override
    public void delete(int index) {
        // 前移[緊縮]
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        elements[size - 1] = null;
        size -= 1;
    }

    /**
     * 將指定索引位置的元素替換成新元素
     * @param index
     * @param newElement
     */
    @Override
    public void update(int index, Object newElement) {
        elements[index] = newElement;
    }

    /**
     * 當前列表中是否含有target這個元素
     * @param target
     * @return
     */
    @Override
    public boolean contains(Object target) {

        return indexOf(target) >= 0;
    }

    /**
     * 返回指定索引處的元素
     * @param index
     * @return
     */
    @Override
    public Object at(int index) {

        return elements[index];
    }

    /**
     * 查詢element的索引,如果沒有返回-1 
     * @param element
     * @return
     */
    @Override
    public int indexOf(Object element) {
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(element)) {
                return i;
            }
        }
        return -1;
    }

}