自定义ArrayList类

```java


/**
 * 自定义MyArrayList类
 *
 * @param <E> 泛型
 * @author Anonymous
 */
public class MyArrayList<E> {
    /**
     * 保存数据的Object类型数组
     */
    private Object[] elementData = null;

    /**
     * 默认初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 数组容量最大值
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;


    /**
     * 底层数组中有效元素个数
     */
    private int size = 0;

    /**
     * 无参数构造方法，默认容量为10
     */
    public MyArrayList() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

    /**
     * 可以提供给用户指定底层数组容量的构造方法
     *
     * @param initCapacity 用户指定的初始化容量
     */
    public MyArrayList(int initCapacity) {
        if (initCapacity > 0) {
            elementData = new Object[initCapacity];
        } else if (0 == initCapacity) {
            elementData = new Object[DEFAULT_CAPACITY];
        } else {
            throw new IllegalArgumentException("指定数组容量不符合！！！");
        }
    }

    /**
     * 尾插法插入指定元素
     *
     * @param e 符合当前泛型的指定元素
     * @return 添加成功返回true
     */
    public boolean add(E e) {
        add(size, e);
        return true;
    }

    /**
     * 在集合指定下标位置添加指定元素
     *
     * @param index 指定的下标位置
     * @param e     符合当前泛型约束指定元素
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new ArrayIndexOutOfBoundsException("数组下标不合法!");
        }
        if (size == elementData.length) {
            grow(size + 1);
        }

        for (int i = size; i > index; i--) {
            elementData[i] = elementData[i - 1];
        }
        elementData[index] = e;
        size += 1;
    }

    /**
     * 删除指定下标位置的元素
     *
     * @param index 指定删除的下标位置
     * @return 删除成功返回对应删除的元素
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("数组下标不合法!");
        }

        E temp = this.get(index);
        for (int i = index; i < size - 1; i++) {
            elementData[i] = elementData[i + 1];
        }

        elementData[size - 1] = null;
        size -= 1;

        return temp;
    }

    /**
     * 删除集合中的指定元素
     *
     * @param obj 指定元素
     * @return 删除元素，返回对应的内容，没有找到，返回null
     */
    public E remove(Object obj) {
        int index = indexOf(obj);

        if (index != -1) {
            return remove(index);
        }

        return null;
    }

    /**
     * 获取指定下标的元素
     *
     * @param index 指定的下标位置
     * @return 对应的元素，没有返回null
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("数组下标不合法!");
        }
        return (E) elementData[index];
    }

    /**
     * 获取有效元素个数
     *
     * @return 返回当前集合中的有效元素个数
     */
    public int size() {
        return size;
    }

    /**
     * 判断当前集合中是否为空
     *
     * @return 为空返回true，不为空返回false
     */
    public boolean isEmpty() {
        return 0 == size;
    }

    /**
     * 判断指定元素是否存在
     *
     * @param obj 指定元素
     * @return 存在返回true，不存在返回false
     */
    public boolean contains(Object obj) {
        return indexOf(obj) != -1;
    }

    /**
     * 从集合中获取对应的子集合，要求从fromIndex开始，到endIndex结束，并且是不要默认的endIndex下标，要头不要尾
     *
     * @param fromIndex 从指定位置开始
     * @param endIndex  到指定位置结束
     * @return 带有子集合的MyArrayList对象
     */
    public MyArrayList<E> subList(int fromIndex, int endIndex) {
        if (fromIndex < 0 || endIndex >= size || endIndex <= fromIndex) {
            throw new ArrayIndexOutOfBoundsException("下标不合法！！！");
        }

        // 根据指定的下标位置，创建对应的空子集合
        MyArrayList<E> temp = new MyArrayList<>(endIndex - fromIndex);

        for (int i = fromIndex; i < endIndex; i++) {
            temp.add(this.get(i));
        }

        return temp;
    }

    /**
     * 使用指定元素，替换指定下标的元素，返回被替换元素
     *
     * @param index 指定下标
     * @param e     指定元素
     * @return 被替换的元素
     */
    public E set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("数组下标不合法!");
        }

        E temp = get(index);
        elementData[index] = e;

        return temp;
    }

    /**
     * 找出指定元素在集合中下标位置
     *
     * @param obj 指定的元素
     * @return 找到返回值大于等于0，没有找到返回-1
     */
    public int indexOf(Object obj) {
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (obj == elementData[i]) {
                index = i;
            }
        }

        return index;
    }

    /**
     * 找出集合中指定元素最后一次出现的位置
     *
     * @param obj 指定的元素
     * @return 对应的下标位置
     */
    public int lastIndexOf(Object obj) {
        int index = -1;
        for (int i = size - 1; i >= 0; i--) {
            if (obj == elementData[i]) {
                index = i;
            }
        }

        return index;
    }

    /**
     * 私有化底层数组扩容方法
     *
     * @param minCapacity 最小要求
     */
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }

        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}