动态数组（数组的增删查改）

在实际生活中，一段数组我们有可能会对其进行增删查改，当我们对数组进行改动后就有可能改变了数组的大小，若是我们每一次改动后都将数组重新开辟空间拷贝过去会相对来说比较麻烦，所以产生了动态数组，对于实际运用来说会比较灵活。动态数组就是在声明的时候没有明确数组大小的数组。
当我们创建了一个动态数组后，需要完善进行增、删、查、改的操作。

public class DynamicArray {
    //定义属性
    //定义存储具体元素的数组
    private int[] elementData;
    //定义当前数组存储元素的个数
    private int size;
    //得到当前数组的长度
    public int getSize() {
        return size;
    }

    //构造函数
    public DynamicArray() {
        //若在使用时没有给定数组大小，则先开辟10个空间
        this.elementData = new int[10];
    }

    public DynamicArray(int size) {
        //若给定了数组的大小，则开辟size个空间
        this.elementData = new int[size];
    }


    /**
     * 给数组拓容
     */
    private void grow() {
        //旧的数组的长度
        int oldLength = elementData.length;
        //设置新数组的长度为就数组的两倍
        int newLength = oldLength << 1;
        //将原来的数组拷贝到新数组里
        elementData = Arrays.copyOf(elementData, newLength);
    }

    /**
     * 在数组的头部插入一个元素
     *
     * @param data 插入data元素
     */
    public void addFirst(int data) {
        //判断数组的空间是否已满，若是满的我们再插入一个元素后会溢出
        if (size == elementData.length) {
            //若空间已满，我们需要对数组进行扩容
            grow();
        }
        //我们要在数组头部插入元素就需要先将现有的所有元素向后移一位，将头部的位置空出来
        for (int i = size - 1; i >= 0; i--) {
            elementData[i + 1] = elementData[i];
        }
        elementData[0] = data;
        size++;
    }

    /**
     * 在数组的尾部插入一个元素
     * @param data 插入data元素
     */
    public void addLast(int data){
        //判断数组的空间是否已满，若是满的我们再插入一个元素后会溢出
        if(size==elementData.length)
        {
            grow();
        }
        elementData[size]=data;
        size++;
    }

    /**
     * 根据索引插入元素
     * @param index 在下标为index的地方进行操作
     * @param data 插入元素data
     */
    public void addIndex(int index,int data){
        //判断数组的空间是否已满，若是满的我们再插入一个元素后会溢出
        if(size==elementData.length)
        {
            grow();
        }
        //如果在0下标处插入元素就是头插，调用addFirst方法
        if(index==0)
        {
            addFirst(data);
        }
        //如果在size下标处插入元素就是尾插，调用addLast方法
        if(index==size)
        {
            addLast(data);
        }
        //在中间位置插入元素，也是将该位置开始所有的元素向后移一个将该位置空出来，把元素插入
        if(index < 0 || index > size)
        {
            System.out.println("该下标不存在！");
        }
        else
        {
            for (int i = size-1; i >= index; i--) {
                elementData[i+1]=elementData[i];
            }
            elementData[index]=data;
            size++;
        }
    }

    /**
     * 判断索引是否合法
     * @param index 检查数组中是否存在index下标
     * @return
     */
    public boolean checkIndex(int index){
        if(index < 0 || index > size-1)
        {
            System.out.println("该下标不存在！");
            return false;
        }
        return true;
    }

    /**
     * 通过索引删除元素
     * @param index 删除index下标的元素
     */
    public void removeIndex(int index){
        //先判断要删除的下标是否合法
        if(checkIndex(index))
        {
            //将该下标开始的元素全部向前移一位
            for (int i = index; i < size-1; i++) {
                elementData[i]=elementData[i+1];
            }
            size--;
        }
    }

    /**
     * 判断data元素是否存在
     * @param data
     * @return
     */
    public boolean checkData(int data){
        for (int i = 0; i < size; i++) {
            if(elementData[i]==data)
            {
                return true;
            }
        }
        System.out.println("该元素不存在！");
        return false;
    }

    /**
     * 将数组中指定元素全部删除
     * @param data 删除data元素
     */
    public void removeData(int data){
        if(checkData(data))
        {
            for (int i = 0; i < size; i++) {
                while(elementData[i]==data)
                {
                    removeIndex(i);
                }
            }
        }
    }

    /**
     * 根据索引查找元素
     * @param index 要查找的下标
     * @return
     */
    public void getIndex(int index){
        //判断索引是否合法
        if(checkIndex(index))
        {
            //返回该下标元素
            System.out.println(elementData[index]);
        }
    }

    /**
     * 查找数组中同一个元素所有的下标
     * @param data 待查找元素
     * @return
     */
    public void getData(int data){
        //判断元素是否存在
        if(checkData(data))
        {
            //循环输出下标
            String ret="[";
            for (int i = 0; i < size; i++) {
                if (elementData[i]==data)
                {
                    ret+=i;
                    ret+=" ";
                }
            }
            ret+="]";
            System.out.println(ret);
        }
    }

    /**
     * 根据索引修改元素
     * @param index 下标位置
     * @param data 更改后的元素
     */
    public void alterIndex(int index,int data){
        if (checkIndex(index))
        {
            elementData[index]=data;
        }
    }

    /**
     * 将数组中同一个元素全部修改为一个新的元素
     * @param oldData 旧的元素
     * @param newData 新的元素
     */
    public void alterData(int oldData,int newData){
        //判断元素是否合法
        if(checkData(oldData))
        {
            for (int i = 0; i < size; i++) {
                //将新的元素赋给旧的元素
                while (elementData[i]==oldData)
                {
                    elementData[i]=newData;
                }
            }
        }
    }

    @Override
    public String toString() {
        String ret="[";
        for (int i = 0; i < size-1; i++) {
            ret+=elementData[i];
            ret+=",";
        }
        ret+=elementData[size-1]+"]";
        return ret;
    }

    public static void main(String[] args) {
        DynamicArray dynamicArray=new DynamicArray();
        dynamicArray.addFirst(5);
        dynamicArray.addLast(3);
        dynamicArray.addFirst(1);
        dynamicArray.addIndex(1,2);
        dynamicArray.addIndex(1,2);
        dynamicArray.addLast(9);
        dynamicArray.addIndex(4,2);
        System.out.println(dynamicArray);
        dynamicArray.alterIndex(3,6);
        System.out.println(dynamicArray);
    }
}