纯手写ArrayList集合

说明：

要想深度学习JavaSE基础知识，阅读源码是必不可少的事情,光看源码也许还不能真正的去理解记忆，去发现底层到底是如何实现的，为了加深自己的记忆就需要自己去手写实现。

底层源码新型Api.底层数组扩容技术System.arraycory(原数组，原数组开始位置，目标数组，目标数组开始位置，复制的长度)

package org.robert.keyv8.hashmap;

/**
 * @Description 纯手写ArrayList(基于数组的实现)
 * @author: 甘华
 * @联系方式 [email protected]
 * @date: 2019/2/13 12:54
 * @version: 1.0
 */
public class MyArrayList {

    /**
     * 底层数组
     */
    private transient Object[] elementData;

    /**
     * 空数据特征显示
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
     * 数组大小
     */
    private int size;

    /**
     * 位置访问操作
     *
     * @param index
     * @return
     */
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * 返回数组大小
     *
     * @return size
     */
    public int size() {
        return size;
    }

    /**
     * 无参构造，通过显式构造调用有参构造
     */
    public MyArrayList() {
        this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * 含参构造器
     * 对传入的初始量的合法性进行检测
     * 通过新建数组实现
     */
    public MyArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("非法容量,容量值为:" + initialCapacity);
        }
    }

    /**
     * 判断是否为空
     *
     * @return boolean
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 添加对象(不指定位置)
     * 首先注意数组的扩容
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        ensureCapacity();
        elementData[size] = e;
        size++;
        return true;
    }

    /**
     * 插入操作(指定位置)
     * 下标合法性检测
     * 数组的扩容
     * 数组的复制
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        rangeCheck(index);
        ensureCapacity();
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = e;
        size++;
    }

    /**
     * 删除指定下标对象,并返回值
     * 下标合法性检测
     * 通过数组的复制来实现
     * 因为前移，数组最后一位要置空
     *
     * @param index
     * @return
     */
    public E remove(int index) {
        rangeCheck(index);
        int arrNums = size - index - 1;
        E oldValue = elementData(index);
        if (arrNums > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, arrNums);
        }
        elementData[--size] = null;
        return oldValue;
    }

    /**
     * 删除指定对象
     * 通过遍历,equals的底层运用，找到下标，调用remove(int index)删除
     *
     * @param obj
     * @return
     */
    public boolean remove(Object obj) {
        for (int i = 0; i < size; i++) {
            if (obj.equals(elementData[i])) {
                remove(i);
            }
        }
        return true;
    }

    /**
     * 将指定下标的对象改变
     * 下标合法性的检查
     * 通过数组的赋值来实现
     * 返回旧值
     *
     * @param index
     * @param e
     * @return
     */
    public E set(int index, E e) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = e;
        return oldValue;
    }

    /**
     * 获取指定下标对象
     *
     * @param index
     * @return
     */
    public Object get(int index) {
        //下标合法性的检测
        rangeCheck(index);
        return elementData[index];
    }

    /**
     * 更新集合数组
     * 检查下标是否合法
     *
     * @param index
     * @param e
     */
    public void update(int index, E e) {
        rangeCheck(index);
        remove(index);
        add(index, e);
    }

    /**
     * 对下标的检查
     *
     * @param index
     */
    public void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("获取下标越界：最大下标为：" + size + "或无此下标");
        }
    }

    /**
     * 扩容
     * 对容器容量的检查
     * 数组的扩容，通过数组复制来实现
     */
    public void ensureCapacity() {
        if (size == elementData.length) {
            Object[] newArray = new Object[size * 2 + 1];
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);
            elementData = newArray;
        }
    }

    /**
     * 清除集合
     */
    public void clear() {
        size = 0;
        elementData = new Object[]{};
    }

}