import java.util.Arrays;

/**
 * @description: 实现基本的 ArrayList 的查询删除增加覆盖操作
 * @author: Rule
 * @date: 2018-09-09 16:37
 **/
public class TestArrayList<E> {

    //定义一个存放数据的数组
    transient Object[] elementData;

    //定义数组的初始化的容量
    private static final int DEFAULT_CAPACITY = 10;

    //定义空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //定义一个默认的空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA ={};

    //定义一个数组最大的长度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    //记录数组中的实际使用的大小
    private int size;



    //具有初始化容量的构造函数
    public TestArrayList(int initialCapacity){
        if (initialCapacity > 0){
            this.elementData = new Object[initialCapacity];
        }else if (initialCapacity == 0){
            this.elementData = this.EMPTY_ELEMENTDATA;
        }else {
            //如果初始的容量 < 0，则抛出异常
            throw new IllegalArgumentException("初始的容量不能小于0！！");
        }
    }

    //不含初始化容量的搞糟参数，采用默认的初始化容量
    public TestArrayList(){
        elementData = new Object[DEFAULT_CAPACITY];
    }

    //根据下标 index 查询出对应的对象
    public E get(int index){

        //首先 对于下标 index，首先执行检查下标是否合法
        checkIndex(index);
        return (E) this.elementData[index];
    }

    private void checkIndex(int index) {
        if (index < 0 || index >= size){
            throw new IndexOutOfBoundsException("index 越界啦！！");
        }
    }


    //添加操作 (不含下标 index 的添加)
    public void add(E e){

        //首先执行添加操作，确定是否进行扩容
        //这句话的意思是，确定容量能否再加一个
        ensureCapacity(size + 1);

        //扩容后，直接执行添加操作
        elementData[size++] = e;

    }

    //添加操作 (含下标 index 的添加)
    public void add(int index, E e){
        //首先含下标的 add() 方法，就是将 index 后面的元素依次后移
        //还是要计算是否能进行扩容操作
        ensureCapacity(size + 1);
        //首先要判断 index 是在什么位置上进行添加操作
        //这个index 就是在数组的末尾进行添加，但是 checkIndex ()检查不包含 index == size 这个条件
        if (index == size){
            //接着执行在末尾继续添加操作
            elementData[size] = e;
        }else{
            //检查下标是否合法
            checkIndex(index);
            /**
             * arraycopy(src, srcPos, dest, destPos, length)这个方法包含了5个参数在这里代表的意思如下
             * src: 原数组
             * srcPos: 原数组的 srcPos 起始位置
             * dest: 目标数组
             * destPos: 目标数组从 destPos 位置开始覆盖
             *length: 是原数组的 从 srcPos 位置起始到后面的长度
             */
            //将 index 后的数据依次往后移动一位
            System.arraycopy(elementData, index, elementData, index+1,size - index);
            //然后对 elementData数组插入 index 位置上的数据
            elementData[index] = e;
        }
        size++;
    }

    //删除操作 (含下标的删除)
    public void remove(int index){

        //首先还是对 index 进行检查
        checkIndex(index);

        // 将需要删除的元素，进行覆盖。 index 后面的元素依次向前进行覆
        System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
        //size实际长度-1
        size--;
    }




    //比较需要的容量和默认的容量
    private void ensureCapacity(int minCapacity) {
        //判断 elementData 还没有进行添加操作
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        //判断需要的容量如果大于
        ensureExplicitCapacity(minCapacity);
    }

    //判断需要的容量如果大于数组的长度
    private void ensureExplicitCapacity(int minCapacity) {
        if (minCapacity > elementData.length){
            //执行扩容操作
            grow(minCapacity);
        }
    }

    //扩容操作,一般是再原基础上扩容 1.5倍
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //扩容 1 + 0.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //出现这种情况，说明内存溢出了
        if (newCapacity < minCapacity){
            newCapacity = minCapacity;
        }
        //如果得到的容量比限定的容量还要大
        if (newCapacity - MAX_ARRAY_SIZE > 0){
            newCapacity = hugeCapacity(minCapacity);
        }

        //对扩容后的容量进行检查后，直接对 elementData 进行扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


    //这个方法告诉我们，elementData 的实际大小为 Integer.MAX_VALUE,而不是定义的 MAX_ARRAY_SIZE;
    private int hugeCapacity(int minCapacity) {
        //minCapacity < 0 说明了，需要的容量小于0，抛出内存溢出异常
        if (minCapacity < 0){
            throw new OutOfMemoryError("需要的容量不能小于0");
        }

        return minCapacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

    //得到 elementData的 实际容量
    public int size(){
        return this.size;

    }
}