自己写Java ArrayList

无需多解释了，有注释。扩容的大小是按照源码中的1.5倍来的，你可以随意。错误之处，请在评论区不吝赐教。

/**
 * @ClassName MyArraylist
 * @Description TODO
 * @Author Handoking
 * @Date 2019/7/17 18:55
 **/



import java.util.Arrays;
import java.util.Objects;

public class MyArraylist implements Cloneable{
    //默认容量
    private final static int DEFAULT_CAPACITY= 3;
    //定义无参数构造函数时默认的数组
    private final static Object[] DEFAULT_ARRAY =new Object[DEFAULT_CAPACITY];
    //为初始化定义空数组
    private final static Object[] EMPTY_ARRAY={};
    //动态数组的长度（元素个数）
    private int size;
    //快速失败等操作使用的modCount
    transient int modCount=0;
    //核心构成-数组
    transient Object[] arr;
    //以下为两个构造函数
    public MyArraylist(){
        this.arr = DEFAULT_ARRAY;
    }
    public MyArraylist(int initCap){
        if(initCap>0){
            arr = new Object[size];
        }else if(initCap==0){
            arr = EMPTY_ARRAY;
        }else{
            throw new IllegalArgumentException("初始容量不能小于0");
        }
        modCount = 0;
    }
    /** 
     *@params  [index]
     *@return  java.lang.Object
     *@author  Handoking
     *@date  2019/7/23 16:12
     */
    public Object get(int index){
        //此处可以用Object类自带的检查边界函数checkIndex
        if(index>=size||index<0){
            throw new IllegalArgumentException("索引值超出容量或者小于0");
        }
        return arr[index];
    }
    /** 
     *@params  [index]
     *@return  java.lang.Object
     *@author  Handoking
     *@date  2019/7/23 16:12
     */
    public Object remove(int index){
        //利用Object类自带的检查边界函数checkIndex
        Objects.checkIndex(index,size);
        //每次删除和添加操作将modCount自增1
        modCount++;
        Object oldValue = arr[index];
        int partLength = size-1-index;
        if(partLength>0){
            //remove的核心，就是对同一数组使用arraycopy函数变相将元素删除
            System.arraycopy(arr,index+1,arr,index,partLength);
        }
        arr[--size] = null;
        return oldValue;
    }
    /** 
     *@params  [value]
     *@return  boolean
     *@author  Handoking
     *@date  2019/7/23 16:12
     */
    public boolean add(Object value){
        modCount++;
        int index = size;
        if(arr.length ==size){
            //扩容操作是必须的
            arr = resize();
        }
        arr[index] = value;
        size++;
        return true;
    }
    /** 
     *@params  扩容操作
     *@return  java.lang.Object[]
     *@author  Handoking
     *@date  2019/7/23 16:12
     */
    private Object[] resize(){
        //扩容核心，这里可以用更简洁的用Arrays.copyof代替
        Object[] newArr = new Object[size+(size>>1)];
        System.arraycopy(arr,0,newArr,0,arr.length);
        return newArr;
    }
    @Override
    /** 
     *@params  克隆函数的重写，需要实现cloneable接口
     *@return  java.lang.Object
     *@author  Handoking
     *@date  2019/7/23 16:20
     */
    public Object clone(){
        //在方法中直接处理克隆抛出的异常，调用时就不要再处理了，方便用户调用
        try{
            MyArraylist cower = (MyArraylist) super.clone();
            cower.arr = Arrays.copyOf(arr,arr.length);
            return cower;
        }catch(CloneNotSupportedException e){
            throw new InternalError(e);
        }
       
    }
    //debug测试
    public static void main(String[] args){
        MyArraylist co = new MyArraylist();
        co.add(6);
        co.add(3);
        co.add(7);
        co.add(4);
        System.out.println(co.get(2));
        co.remove(0);
        MyArraylist cower = (MyArraylist) co.clone();
    }
}