一  .   陣列

1.陣列，可以說是JAVA中最常見和簡單的資料結構，但是，萬不可小瞧了資料，古書有言：大道至簡。

2.陣列基礎

1）陣列優點：根據下標快速查詢；

2）陣列最好應用於“索引有語意”的情況，例如陣列int[] scores代表全班同學的成績，scores[2]應當代表學號為2的同學的成績。

反之，如果陣列的索引沒有語意，可以使用別的資料結構。但是，並非所有有語意的索引適合陣列，例如身份證，因為18位的身份證號，會佔用大量的儲存空間。接下來，本人主要研究沒有索引語意的陣列，基於java陣列二次封裝屬於我們的陣列。製作屬於我們的陣列類：

  class Array 

               size = 0

下面貼出程式碼，定義一個泛型的陣列，支援動態擴容，支援增、刪、改、查。

public class Array<E> {

    private E[] data;
    private int size;

    /**
     * 傳入陣列的容量capacity構造Array
     *
     * @param capacity
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    public Array() {
        this(10);
    }

    //獲取陣列的元素個數
    public int getSize() {
        return size;
    }

    //獲取陣列容量
    public int getCapacity() {
        return data.length;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    //向所有元素後新增一個新元素
    public void addLast(E e) {
       add(size,e);
    }

    //向所有元素前新增一個新元素
    public void addFirst(E e) {
       add(0,e);
    }

    //在特定位置新增元素
    public void add(int index, E e){
        if (size == data.length)
            throw new IllegalArgumentException("陣列空間已滿");
        if(index < 0 || index > size)
            throw new IllegalArgumentException("index < 0 或者 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++;
    }

    // 動態擴容陣列
    private void resize(int newCapacity) {
        E[] newData = (E[])new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
            data = newData;
        }
    }

    // 查詢指定位置的元素
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index < 0 或者 index >= size");
        }
        return data[size];
    }

    public void set(int index, E e) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index < 0 或者 index >= size");
        }
        data[index] = e;
    }

    public boolean contains(E e){
        for (int i = 0; i < size; i++) {
            if(data[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    // 查詢陣列元素e的索引，不存在元素e，返回-1
    public int find(E e){
        for (int j = 0; j < size; j++) {
            if(data[j].equals(e)){
                return j;
            }
        }
        return -1;
    }

    //刪除指定位置的元素
    public E remove(int index){

        if(index < 0 || index > size)
            throw new IllegalArgumentException("index < 0 或者 index > size");
        E ret = data[index];
        for (int i = index + 1; i < index; i++) {
            data[i-1] = data[i];
        }
        size--;
        data[size] = null;
 

//陣列縮小縮容
if(size == data.length/2){
    resize(size/2);
}

        return ret;
    }

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

    //刪除最後一個元素
    public E removeLast(){
        return remove(size-1);
    }

    public boolean removeElement(E e){
        int index = find(e);
        if(index != -1){
            remove(index);
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("[");
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if(i != size-1){
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }
}