手写ArrayList数组

介绍就不介绍了，我自己手写了ArrayList的add、remove、replace等方法，写的不好别见怪。也请各位大佬指教！
直接上代码吧

package arrayList;

/**
 * @author Cris
 * @version 1.0
 * @className MyArrayList
 * @description <手写ArrayList>
 * @date 2020/1/21 21:18
 */
public class MyArrayList {
    //原始数组
    private Object[] data;
    //数组的个数
    private int size;

    //有参构造，创建初始容量
    public MyArrayList(int initSize){
        if(initSize > 0) {
            data = new Object[initSize];
        }else{
            throw new RuntimeException("数组容量不能为负数！");
        }
    }

    //无参构造
    public MyArrayList(){
        //无参调用有参
        this(16);
    }

    //获得ArrayList的有效数据个数
    public int getSize(){
        return size;
    }

    //获得ArrayList的容量
    public int getLength(){
        return data.length;
    }

    /**
     *往数组最后一个位置添加object元素
     * @param object ：需要添加的元素
     */
    public void add(Object object){
        Capacity();
        data[size++] = object;
    }

    /**
     * 按照指定位置添加元素
     * @param index 添加元素的位置
     * @param object 添加的内容
     */
    public void add(int index,Object object){
        //检查index是否越界
        CheckIndex(index);
        //是否需要扩容
        Capacity();

        //系统自带的数组复制方法，将愿数组的index位置以后的所有的数据往后移动一个位置
        //System.arraycopy(data,index,data,index+1,size-index);

        /**
         * 自己写的复制方法
         *创建临时数组，长度与data一致
         * 将index位置之前的全部复制到tempArray中去
         * 将object赋值给tempArray[index]
         * 将index之后的数据全部赋值给tempArray
         * tempArray指向data
         */
        Object[] tempArray = new Object[data.length];
        for(int i = 0;i < index;i++){
            tempArray[i] = data[i];
        }
        tempArray[index] = object;
        for(int i = index+1;i < data.length;i++){
            tempArray[i] = data[i-1];
        }
        data = tempArray;
        size++;
    }

    /**
     * 返回指定位置的元素数据
     * @param index 指定的位置
     * @return 返回index位置的元素
     */
    public Object getByIndex(int index){
        //检查下标是否越界
        CheckIndex(index);
        return data[index];
    }

    /**
     * 返回指定数据的下标。只返回第一次出现在数组的位置
     * @param object
     * @return 存在则返回下标，不存在返回-1
     * 首先判断元素值是不是null，因为ArrayList可以存储null，
     * 如果元素值本身是null，返回其第一次出现的下标
     * 如果不是null，遍历数组，返回第一次出现的下标
     * 找不着返回-1
     */
    public int getIndex(Object object){
        if(object == null){
            for(int i = 0;i< size;i++){
                if(null == data[i])
                    return i;
            }
        }else{
            for(int i = 0;i< size;i++){
                if(object.equals(data[i]))
                    return i;
            }
        }
        return -1;
    }

    /**
     * 得到ArrayList的所有值的数组，该数组只包含ArrayList的实际数据
     * 也就是说后面为null的不显示
     * @return 返回数组
     */
    public Object[] getAll(){
        //Arrays的复制工具
//        return Arrays.copyOf(data,size);
        //自己实现
        Object[] tempArray = new Object[size];
        for(int i = 0;i < size;i++){
            tempArray[i] = data[i];
        }
        return tempArray;
    }

    /**
     * 替换指定下标的元素值为value
     * @param index 指定的下标
     * @param value 替换后的值
     */
    public void replace(int index,Object value){
        //检查下标
        CheckIndex(index);
        data[index] = value;
    }

    /**
     * 删除指定下标的元素值
     * @param index 指定的下标
     * 首先检查下标是否合理，并判断下标是否在[0-size]之内；
     */
    public void remove(int index){
        //检查下标的合理性
        CheckIndex(index);
        //判断index是否在合理范围，即是否超出了有效数据的范围
        int num = size-index-1;
        if(num >= 0){
            //System.arraycopy(data,index+1,data,index,size-index-1); 系统的数组复制工具
            //data[size-1] = null;复制完后将最后一位制为null。
            /**
             * 自己实现
             * 创建临时数组，将index之前的全部复制到临时数组；
             * 将原数组[index+1,size)复制到临时数组[index,size-1)
             * 实际容量减一，临时数组指向原数组。
             */
            Object[] tempArray = new Object[data.length];
            for(int i = 0;i < index;i++){
                tempArray[i] = data[i];
            }
            for(int i = index+1;i<size;i++){
                tempArray[i-1] = data[i];
            }
            size--;
            data = tempArray;
        }else{//index下标位没有值
            throw new IndexOutOfBoundsException("Index:"+index+",Size："+size);
        }
    }
    /**
     * 删除指定的元素值
     * @param object 删除的元素值
     *
     */
    public void remove(Object object){
        //得到object对应的下标
       int index = getIndex(object);
       //根据下标删除元素
       remove(index);
    }

    /**
     * 检查下标是否越界
     * @param index
     */
    private void CheckIndex(int index) {
        if(index < 0 || index > data.length){
            throw new RuntimeException("下标越界，"+index+"应该大于0小于ArrayList的长度。");
        }
    }

    /**
     * 判断数组是否需要扩容
     */
    private void Capacity() {
        //判断数组是否需要扩容
        if(size == data.length){
//            Arrays自带的数组复制方法
//            data = Arrays.copyOf(data,(int)(size*1.5));

            /*
            * 自己写的数组复制；
            * 当ArrayList满了就直接创建一个临时数组，容量为原来的数组的2.5倍
            * 然后将原来的数组的所有数据复制到新数组
            * 新数组再指向旧数组
            * */
            Object[] tempArray = new Object[(int)(size*2.5)];
            for (int i = 0;i < data.length;i++){
                tempArray[i] = data[i];
            }
            data = tempArray;
        }
    }

}

下面贴上测试的代码和数据

import arrayList.MyArrayList;

import java.util.Arrays;

public class TestMyArrayList {
    public static void main(String[] args) {
        MyArrayList list=new MyArrayList();
        for(int i=0;i< 10;i++){
            list.add(i+1+"小明");
        }
        System.out.println(Arrays.toString(list.getAll()));
        System.out.println("=====================================");
        list.add(2,"插队");
        System.out.println(Arrays.toString(list.getAll()));
        System.out.println("=====================================");
        list.remove(2);
        System.out.println("剔除插队的："+Arrays.toString(list.getAll()));
        System.out.println("=====================================");
        list.replace(1,"11小明");
        System.out.println("11小明替换了2小明："+Arrays.toString(list.getAll()));
        System.out.println("=====================================");
        list.remove("1小明");
        System.out.println("1小明离开了："+Arrays.toString(list.getAll()));
        System.out.println("=====================================");
        int index = list.getIndex("4小明");
        System.out.println("4小明的位置："+index);
        System.out.println("=====================================");
        Object object = list.getByIndex(5);
        System.out.println("第5个位置是："+object);
        System.out.println("=====================================");
        System.out.println("现在ArrayList的长度是："+list.getLength());
        System.out.println("现在ArrayList的实际元素个数是："+list.getSize());


    }
}

不足之处请各位大佬指正！谢谢！