不要小瞧数组（用静态数组实现我们自己的动态数组）

（希望我所描述的一切，给你带来收获！）

我们将要使用的是JAVA中的静态数组——E[] data = new E[]();去实现一个属于我们自己的动态数组

 

第一步：（关于泛型不作过多解释）

public class Array<E> {
    private E[] data;
    private int size;
}

data是我们需要的数组，size是我们需要维护的动态数组的长度；size可以认为是数组的索引号，size总是指向数据的末端——当整个数组为空时size指向的是 data[0] 的位置，当数组只有 data[0] 一个元素时，size指向的数据末端是 data[1];也就是说，size总是指向用户数据(用户添加的数据)的后一个位置。

 

第二步：

/**
     *
     * @param capacity
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
    }

我们申请一个容量为capacity的数组，注意！java中不能直接对泛型进行new的操作，但Object是所有类的父类，通过new一个Object再进行类型强转是行得通的！但是，有时我们并不确定我们所需要多少大小的capacity，为了方便，我们还需要一个无参构造函数，初始化一个默认的capacity数组（默认的capacity我给的是10）

/**
     * the default capacity is 10
     */
    public Array() {
        this(10);
    }

 

第三步：实现一些简单的操作，例如：获取当前数组的长度、判断数组是否为空......

/**
     *@return the current data length of the array
     */
    public int getSize() {
        return size;
    }

    /**
     * Determines whether the array is empty
     * @return  false or true
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * get the Array capacity
     * @return  Array capacity
     */
    public int capacity() {
        return data.length;
    }

 我们一定要明确的一点是：用户只能看到size长度的data(这是外界给予可能是有价值意义的数据)，而data.length则只是能承载多少用户数据的边界（限度）

 

 第四步：为我们的Array<E>实现增加元素的操作add(int index,E e)方法

/**
     * Insert an element on an index
     * @param index
     * @param e
     */
    public void add(int index,E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed.Array is full");
        for (int i = size - 1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size++;
    }

 需要注意的是，用户指定位置插入元素，index值一定要具有合法性——即index属于[0,size] 

 循环体中，data[i+1] = data[i]的语义是明显的——前一个元素向后一个元素移动。最初的移动在Array的尾部，即是 size - 1 的位置

 

第五步：移除Array中的所有的元素e

我们先理清思路：1、移除元素e我们需要先获得元素e所在的index

　　　　　　　　2、通过目标index，我们只需要进行 data[index] = data[ index + 1 ]——拿目标元素所在位置的下一个位置上的元素去覆盖目标元素

　　　　　　　　3、覆盖操作肯定是在循环中进行的，因为不一定只有一个元素e，很可能有相连的e，这时，当第一次覆盖操作结束之后，我们应该还需要再考察覆盖之后的index是否还是e

/**
     * remove all "e" from the array
     * @param e
     */
    public void removeElements(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                remove(i);
                i--;
            }
        }
    }

 removeElements(E e)复用了remove(int index)

/**
     * remove elements from index positions
     * @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 + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        return ret;
    }

 关于removeElements(E e)其实还有其他方法去实现，在这里小编就再列个方法：我们可以构建一个removeElement(E e)方法，这个方法每运行一次就移除Array中首个元素e，那么我们可以在removeElements(E e)中复用此方法，逻辑上加以判断就好

 

第六步：当我们添加的数据长度超出capacity容量时就应该考虑换一个更大的数组去容纳这些数据！

private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

 主要是在添加方法中复用该resize方法

/**
     * Insert an element on an index
     * @param index
     * @param e
     */
    public void add(int index,E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed.Array is full");
        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++;
    }

 假设data数组的容量为10，那么最大索值index就为为9，当index == 9这个位置存入值时，size即为10，所以用if (size == data.length)去判断数组是否应该扩     容。当数组空间已经装满数据，我们再次添加数据时就会触发resize方法，使得数组“扩容”。

以下是缩容的算法

/**
     * remove elements from index positions
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index >= size)
            throw  new IllegalArgumentException("remove failed,array is full");
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        if (size == data.length/4 && data.length/2 != 0) {
            resize(data.length/2);
        }
        return ret;
    }

 我们判定数组缩容的条件是 size == data.length/4，即当前数据的总量只用capacity总容量的 1/4。

 为什么不是 size == data.length/2 ？

 理由：如果是 size == data.length/2 就开始缩容的话，那么当我们再次添加元素时又会进行扩容，两次基本的O(1)的操作却触发了两次O(n)的数组拷贝，试想一下，如果我的操作是反复的在 size == data.length/2 时添加和移除呢？势必每一次的操作都会是O(n)级别的复杂度！这就是复杂度的震荡!

 data.length/2 != 0    ===> 考虑data.length == 1时， 1/2 == 0，数组的容量自然是不能为0的!