自己实现简单的ArrayList

看完ArrayList的源码后，自己尝试着写一个简单的版本。

import java.io.Serializable;
import java.util.Arrays;

/**
 * @文件名：MyArrayList
 * @创建人: wangsheng
 * @创建时间: 2020/3/18
 * @描述:
 */
public class MyArrayList<E> implements Serializable {
    // 默认的容量
    private static final int DEAFAULT_CAPACITY = 10;
    // 空的数组
    private static final Object[] EMPTY_ELEMENTDATA= {};
    //
    private static final Object[] DEAFAULTCAPACITY_EMPTY_ELEMENTDATA={};
    // 储存用的数组
    // 进行非序列化
    transient Object[] elementData;
    // List长度
    private int size;

    public MyArrayList(){
        this.elementData = EMPTY_ELEMENTDATA;
    }

    public MyArrayList(int initialCapacity){
        if(initialCapacity > 0){
            this.elementData = new Object[initialCapacity];
        } else if(initialCapacity == 0){
            this.elementData = EMPTY_ELEMENTDATA;
        } else{
            throw new IllegalArgumentException("错误的定义容量：" + initialCapacity);
        }
    }

    // 获取数组中的指定下标的数据
    E elementData(int index){
        return (E) elementData[index];
    }

    private void ensureCapacityInternal(int minCapacity){
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private void ensureExplicitCapacity(int minCapacity){
        // modCount++;
        // 如果所需容量大于现在的数组长度，进行扩容
        if(minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private static int calculateCapacity(Object[] elementData, int minCapacity){
        // 说明是第一次扩容，之前并定容量
        if(elementData == DEAFAULTCAPACITY_EMPTY_ELEMENTDATA){
            return Math.max(DEAFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void grow(int minCapacity){
        // 获取旧容量
        int oldCapacity = elementData.length;
        // 赋值1.5倍的旧容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 如果新容量还是不够，进行替换，用所需的最小容量
        if(newCapacity - minCapacity < 0){
            newCapacity = minCapacity;
        }
        // 拷贝一个新容量的数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private void rangeCheck(int index){
        if(index>=size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private String outOfBoundsMsg(int index){
        return "Index:" + index+ ", Size:" + size;
    }

    public E get(int index){
        // 判断输入的下标是否越界
        rangeCheck(index);
        // 返回数组中对应的数据
        return elementData(index);
    }

    public int indexOf(E e){
        if(e==null){
            for(int i=0; i<size; i++){
                if(elementData[i]==e)
                    return i;
            }
        } else{
            for(int i=0; i<size; i++){
                if(e.equals(elementData[i]))
                    return i;
            }
        }
        return -1;
    }

    public E set(int index, E e){
        // 判断输入的下标是否越界
        rangeCheck(index);
        // 先获取之前的oldValue
        E oldValue = elementData(index);
        // 将传进来的e赋值给数组的index位置
        elementData[index] =  e;
        return oldValue;
    }

    public boolean add(E e){
        // 确定容量是否足够
        ensureCapacityInternal(size + 1);
        // size自增，插入e
        elementData[size++] = e;
        return true;
    }

    public E remove(int index){
        rangeCheck(index);
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        if(numMoved > 0)
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        elementData[--size] = null;
        return oldValue;
    }

    public int size(){
        return this.size;
    }
}