[Java知识库]java自定义一个数组类（封装多种方法）

一、自定义数组类的动机

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

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

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!!!");
        }
        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[index]=data[index+1];
        }
        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);
        }
    }
}

三、未解决的问题

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