Java数据结构与算法--运用泛型编程实现自定义可动态伸缩的数组类

使用java，运用泛型编程，实现一个自定义数组类，此类可以做到动态扩展数组长度和动态释放数组空间，同时可以支持各种数据类型（泛型）
自定义类的一个好处是可以根据需求任意去扩充方法，这里开发了一些数组中常见的操作方法

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

    /**
     * 构造函数，传入数组的容量capacity构造Array
     * @param capacity
     */
    public Array(int capacity)
    {
        this.data=(E[]) new Object[capacity];
        this.size=0;
    }

    /**
     * 无参数的构造函数，默认初始化一个长度为10的空数组
     */
    public Array()
    {
        this(10);
    }

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

    /**
     * 获取数组的容量
     * @return
     */
    public int getCapacity()
    {
        return this.data.length;
    }

    /**
     * 返回数组是否为空
     * @return
     */
    public boolean isEmpty()
    {
        return this.size==0;
    }

    /**
     * 向数组的末尾增加一个元素
     * @param elem
     */
    public void addLast(E elem)
    {
        this.insert(this.size,elem);
    }

    /**
     * 向数组的起始位置增加一个元素
     * @param elem
     */
    public void addFirst(E elem)
    {
        this.insert(0,elem);
    }

    /**
     * 在数组指定index插入元素
     * @param index
     * @param elem
     */
    public void insert(int index,E elem)
    {
        if(index<0||index>this.size)
        {
            throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");
        }
        if(this.size==this.data.length)
        {
            this.resize(2*this.data.length);
        }
        for(int i=this.size-1;i>=index;i--)
        {
            this.data[i+1]=this.data[i];
        }
        this.data[index]=elem;
        this.size++;
    }

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

    /**
     * 根据索引index获取index处的元素的值
     * @param index
     * @return
     */
    public E get(int index)
    {
        if(index<0 || index>=this.size)
        {
            throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");
        }
        return this.data[index];
    }

    /**
     * 对索引index处的值进行设置
     * @param index
     * @param elem
     */
    public void set(int index,E elem)
    {
        if(index<0 || index>=this.size)
        {
            throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");
        }
        this.data[index]=elem;
    }

    /**
     * 删除数组中第一个元素
     * @return
     */
    public E removeFirst()
    {
        return remove(0);
    }

    /**
     * 删除数组最后一个元素
     * @return
     */
    public E removeLast()
    {
        return remove(this.size);
    }

    /**
     * 根据指定的值删除数组中的元素，数组中若存在多个值，则删除第一个值
     * @param elem
     */
    public void removeElement(E elem)
    {
        int index=this.indexOf(elem);
        if(index!=-1)
        {
            this.remove(index);
        }
    }

    /**
     * 删除指定index索引处的元素
     * @param index
     * @return
     */
    public E remove(int index)
    {
        if(index<0 || index>=this.size)
        {
            throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");
        }
        E ret=this.data[index];
        for(int i=index;i<this.size-1;i++)
        {
            this.data[i]=this.data[i+1];
        }
        this.size--;
        this.data[this.size]=null;
        // 当数组中元素的个数为数组长度的1/4时，释放1/2的数组空间
        // 判断数组中元素个数为数组长度的1/4,而不是1/2，是为了解决和insert方法动态扩展数组时产生复杂度震荡的问题
        if(this.size==this.data.length/4 && this.data.length/2 !=0 )
        {
            this.resize(this.data.length/2);
        }
        return ret;
    }

    /**
     * 判断数组中是否存在指定元素值，若存在返回true，否则返回false
     * @param elem
     * @return
     */
    public boolean contains(E elem)
    {
        for(int i=0;i<this.size;i++)
        {
            if(this.data[i].equals(elem))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取元素在数组中的索引，若不存在，则返回-1，若存在多个，则返回第一个元素的索引值
     * @param elem
     * @return
     */
    public int indexOf(E elem)
    {
        for(int i=0;i<this.size;i++)
        {
            if(this.data[i]==elem)
            {
                return i;
            }
        }
        return -1;
    }
    
    @Override
    public String toString()
    {
        StringBuilder res=new StringBuilder();
        res.append(String.format("Array:size= %d , capacity = %d\n",this.size,this.data.length));
        res.append("[");
        for(int i=0;i<this.size;i++)
        {
            res.append(this.data[i]);
            if(i != this.size-1)
            {
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }
}