java自定义一个数组类（封装多种方法）

一、自定义数组类的动机

         java给定的数组为静态的，我们是无法对齐进行灵活的操作，比如指定位置添加元素，删除元素，判断是否非空等，于是我们便需要利用“面向对象”的设计模式，自定义一个数组类，将这些我们可能需要的方法功能封装进去，使得数组可以灵活进行增删改查判空等操作，即“动态数组”。

二、特点

        该数组类的特点就是动态：即可以在用户添加数组新元素时，如果容量已满，会扩容到原来容量的两倍，这使得数组不再是静态的，而是可以与集合相似，进行扩容动作。然而也有相应的问题：如果数组删除若干元素后，数组的空闲容量大于等于总容量的一半时，我们可以认为，数组空间过剩，所以我们可以考虑适当的减小数组的容量来减小空间的浪费。但是问题也就在于此：如果数组容量为11,、12、15、18等这几个数及其倍数，那么我们该对数组容量减少多少合适呢，全部除以二肯定不合适（有余数），再设想，如果在100万容量的数组空出来了70万，那么我们减多少呢？固定的数值肯定不合适，所以我没有在类中写相关的缩小数组容量的方法，没有找到合适的解决方案。希望有大佬不吝赐教指点一下！

二、代码（注释均已写清楚）

package custom.array;


import java.util.ArrayList;
import java.util.NoSuchElementException;

/**
 * @author ghCode
 * @Email:2085264964@qq.com
 * 自定义数组泛型类，封装为属于自己的数组。
 * 运用面向对象设计模式，将大量的方法封装到类，并泛化。
 */
public class CustomArray<E>{
    private E[]data;//数组data
    private Integer size=0;//数组实际存在的元素

    /**
     * 有参构造，传入capacity数组容量，即array.length
     * @param capacity 数组容量
     */
    public CustomArray(Integer capacity){
        size=0;
        data=(E[])new Object[capacity];//由于java不支持泛型直接实例化，所以要用Object类过渡然后强转。
    }

    /**
     * 默认无参构造函数，将数组大小设置为10
     */
    public CustomArray(){
        this(10);
    }

    /**
     *有参 构造函数
     * @param array 用户传进数组
     */
    public CustomArray(E[] array){
        data=array;
        size=array.length;
    }

    /**
     * 获取数组现有元素个数
     * @return
     */
    public Integer getSize(){
        return size;
    }

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

    /**
     * 判断数组是否为空
     * @return
     */
    public boolean isEmpty(){
        return size==0;
    }

    /**
     * 向指定索引位置添加元素进数组
     * @param index 索引
     * @param element 元素
     */
    public void addIndexElement(Integer index,E element){
        /*//先判断数组是否有空间能继续插入元素————使用动态数组扩容，无需判断空间是否够用。
        if (size== data.length){
            throw new IllegalArgumentException("The Array is full!!!");
        }*/
        //再判断参数是否合法！！！
        if (index<0||index>size){//索引不能小于零且如果大于size则数组元素不连续
            throw new IllegalArgumentException("Parameters index of illegal!!!");
        }
        if (size== data.length) {
            resize((int) (data.length * 2.0));//进行扩容。
        }
        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=element;
        size++;
    }

    /**
     * 在数组第一个位置添加元素。
     * @param element 元素
     */
    public void addFirst(E element){
        addIndexElement(0,element);//复用addIndexElement方法
    }

    /**
     * 在数组末尾添加元素
     * @param element
     */
    public void addLast(E element){
        addIndexElement(size,element);//复用addIndexElement方法
    }

    /**
     * 自定义toString方法，设计需要的的输出格式
     * @return 数组基本信息及内容
     */
    @Override
    public String toString(){
        StringBuilder sb=new StringBuilder();
        sb.append(String.format("Array:size=%d, capacity=%d\n",size, data.length));//格式！
        sb.append('[');
        for (int i=0;i<size;i++){
            sb.append(data[i]);
            if (i<size-1){
                sb.append(',');
            }
        }
        sb.append(']');
        return sb.toString();
    }

    /**
     * 查找元素是否存在与数组中，存在则返回该元素索引,若找不到则抛出异常，
     * 这里考虑数组元素可能重复，有多个索引结果。所以将元素存入ArrayList集合中
     * @param element
     * @return 存放索引集合
     */
    public ArrayList<Integer> getElement(E element){
        ArrayList indexList=new ArrayList();
        for (int i=0;i<size;i++){
            if (data[i]==element){
                indexList.add(i);
            }
        }
        if (indexList.isEmpty()){
            throw new NoSuchElementException("Element no exist!");
        }
        return indexList;
    }

    /**
     * 获取某个位置的元素
     * @param index 索引
     * @return 元素
     */
    public E getIndexElement(int index){
        //先判断索引是否合法
        if (index<0||index>=size){
            throw new IllegalArgumentException("Index is Illegal!");
        }
        return data[index];
    }

    /**
     * 更新某个位置的元素值,并将旧元素返回，提高适用范围。
     * @param index 索引
     * @param element 新元素
     */
    public E updateElement(int index,E element){
        //先判断索引是否合法
        if (index<0||index>=size){
            throw new IllegalArgumentException("Index is Illegal!");
        }
        E oldElement=data[index];//将旧元素先保存
        data[index]=element;
        return oldElement;
    }

    /**
     * 删除某个位置元素，并返回被删除掉的元素
     * @param index 索引
     * @return E 被删除的元素
     */
    public E deleteElement(int index){
        if (index<0||index>=size){
            throw new IllegalArgumentException("Index is Illegal!");
        }
        E result=data[index];
        for (int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
        size--;
        return result;
    }

    /**
     * 删除头个元素
     * @return 被删除的元素
     */
    public E deleteFirst(){
        return deleteElement(0);
    }

    /**
     * 删除末尾元素
     * @return 被删除的元素
     */
    public E deleteLast(){
        return deleteElement(size-1);
    }

    /**
     * 判断某个元素是否存在于数组中，若存在则删除。
     * @param element
     */
    public void JudgeDelete(E element){
        ArrayList<Integer> eList = getElement(element);
        for (Integer index : eList) {
            deleteElement(index);
        }
    }

    /**
     * 当数组已满或闲置空间大于等于容量一半时，才可调用
     * 扩容数组，重置data的容量，使得数组变为像arrayList那样的动态数组。
     * @param newCapacity 新的容量 此处扩容为2倍，避免出现小数容量
     */
    private void resize(int newCapacity){
        E[] newData=(E[])new Object[newCapacity];//构造一个新数组，因为java不支持new一个E类型，所以要Object强转。
        for (int i=0;i< data.length;i++){
            newData[i]=data[i];//将data里的元素，放入newData中
        }
        data=newData;
    }
}

三、未解决的问题

        对于这个自定义数组类，我尚未实现对于数组的正序跟逆序排序，因为对于泛型，java无法对其进行加减运算，而在排序方法中继承Comparable接口进行对于元素大小的比较，但是数组data却无法作为参数参与到方法中，提示：E类型的data实例化的问题，想了很多办法一直无法顺利解决，希望有会的朋友能给我指点，一定虚心请教。