封装一个自定义ArrayList

根据对ArrayList的理解封装一个指定的集合数组（CustomArray）；

CustomArray类：

public class CustomArray<E> {

    //private int[] data;
    private E[] data;

    private int size;

    //构造函数，出入数组的容量capocity构造CustomArray
    public CustomArray(int capacity){
        //data = new int[capacity];
        /**
         * java语言中不支持泛型语法，因为泛型是java在1.5之后引入的，这是一个历史
         * 遗留问题。所以我们在声明泛型类数组的时候，要有用一个折中的方案现用Object
         * 声明一个数组，再强转为泛型类型（E[]）
         * */
        data = (E[])new Object[capacity];
        size = 0;
    }

    public CustomArray(){
        this(10);
    }

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

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }
    //返回数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 想所有的元素后添加一个新的元素
    public void addLast(E e){
        if(size == data.length){
            throw new IllegalArgumentException("AddLast failed.CustomArray is full.");
        }
        data[size] = e;
        size ++;
    }
    public void addLastPuls(E e){
        add(size,e);
    }

    public void addFirst(E e){
        add(0,e);
    }

    // 在第index个位置插入一个新的元素e
    public void add(int index,E e){
        if(size == data.length)
            //throw new IllegalArgumentException("Add failed.Array is full.");
            resize(2 * data.length);

        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed.Require index >= 0 and index <= size");
        }
        for(int i = size - 1;i >= index; i--){
            data[i+1] = data[i];
        }
        data[index] = e;
        size ++;
    }

    // 获取index索引位置的元素
    public E get(int index){
        if(index<0 || index>=size)
            throw new IllegalArgumentException("Get failed.Index is illegal.");
        return data[index];
    }
    // 修改index索引位置的元素为e
    public void set(int index, E e){
        if(index<0 || index>=size)
            throw new IllegalArgumentException("Get failed.Index is illegal.");
        data[index] = e;
    }
    // 查看数组中是否有元素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 i = 0; i < size; i++){
            if (data[i].equals(e))
                return i;
        }
        return -1;
    }

    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--;
        data[size] = null;//loitering object

        if(size == data.length/4 && data.length / 2 != 0)
            resize(data.length / 2);
        return ret;
    }
    // 从数组中删除第一个元素，返回参数的元素
    public E removeFirst(){
        return remove(0);
    }
    // 从数组中删除最后一个袁术，返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    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 , capadity = %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();
    }

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

CustomArrayTest 测试类：

public class CustomArrayTest {

    public static void main(String[] args) {
        CustomArray<Integer> arr = new CustomArray<Integer>(10);
        for(int i = 0; i < 10; i++){
            arr.addLast(i);
        }
        System.out.println(arr);
        arr.add(1,100);
        System.out.println(arr);

        arr.addFirst(-1);
        System.out.println(arr);
        /*
        arr.remove(2);
        System.out.println(arr);

        arr.removeElement(4);
        System.out.println(arr);
        */
    }

}

这里引入两个概念：

1、复杂度分摊：

针对某一功能足够多长的操作，并将期间总体所需的运行时间分摊值各次操作；

2、复杂度震荡：

我们在数组末尾频繁的增加和删除一个元素的时候，造成CustomArray的add功能的复杂度不断地高低变化，这个与静态数组的动态的扩容和缩容有关。

我们都知道在数组添加一个元素非常方便data[size]=e，这个操作的复杂度应该是O(1)级别的，但是数组是静态的数据结构，数组的容量最开始就是设置好的，后期不能改变，而我们在CustomArray中我们要实现动态的效果，就需要对这个静态的数据接口进行扩容，而另一种情况下我们不断的删除CustomArray中的元素，也就是删除静态数组中存储的元素，这种删除是将数组中某个下标位置的内容设置为null，这种删除并不能真删除，被删除的元素所在内存依旧被占用，这就导致了内存的浪费，所以在数组元素过少的时候，就需要对数组进行缩容，不管是扩容还是缩容，都是通过创建一个新的数组，将原数组中的内容指向复制到新的数组上，这个操作是O(n)级别的，如果扩容和缩容的阀值如果设置不当的话就有可能照成复杂度震荡；

如果我们将扩容的值设置成原值的2倍，再将缩容的阀值设置为size<1/2，当静态数组在没有存放满时，我们的插入应该是O(1)级别的，当数组的值存满时，因为牵扯到resize()扩容，它的复杂度应该是O(n)级别的，如果我们频繁的对这个值进行删除和插入操作，就会不断的进行扩容和缩容操作，复杂度也就有原来的O（1）变成了O（n），这就是复杂度震荡；

解决方案：

解决方案很简单就是将扩容的值与缩容的阀值之间留出缓冲的空间，也就是缩容的时候不要太着急，比如把缩容的阀值设置为size<1/4，再对数组进行resize缩容操作，缩小为原来的1/2；

在ArrayList中扩容是扩大1/2倍；

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

ArrayList的删除操作是现将被删除元素的值前面的数据往前移动一位，再把末尾后的值设置为null；

/**
 * Removes the element at the specified position in this list.
 * Shifts any subsequent elements to the left (subtracts one from their
 * indices).
 *
 * @param index the index of the element to be removed
 * @return the element that was removed from the list
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}