/**
 * 自己实现arraylist
 * 添加 add(E e) add(int index,E e)
 * 获取 get(int index)
 * 删除 remove(int index)  remove(object o)
 * 替换 set(int index)
 * 长度 getSize()
 * @author cuiyc
 * @version 1.0
 * @date 2021/6/5 09:15
 */
public class ArrayListDemo2<E> {
    /**
     * list的长度
     */
    private int size;

    private Object[] elemendData;
    /**
     * list的默认的长度为10
     */
    private static final int DEFAULT_CAPACITY=10;

    /**
     * 默认容量的object类型的数组
     */
    private static final Object[] DEFAULT_CAPACITY_ELEMENTDATA={};

    /**
     * 空参构造函数
     */
    public ArrayListDemo2(){
        this.elemendData=DEFAULT_CAPACITY_ELEMENTDATA;
    }

    /**
     * 带初始长度的构造函数
     * @param capacity
     */
    public ArrayListDemo2(int capacity){
        this.elemendData=new Object[capacity];
    }

    /**
     * 添加元素
     * @param e 要添加的元素
     * @return 处理结果
     */
    public Boolean add(E e){
        //1 需要确保数组的容量
        ensureListCapacity(size+1);
        //2 添加元素到list中
        elemendData[size++]=e;
        return true;
    }

    /**
     * 在list的某个位置上添加元素
     * @param index list的数组的位置
     * @param e 要添加的元素
     */
    public void add(int index,E e){
        //1 确保数组的容量
        ensureListCapacity(size+1);
        //2 数据的拷贝
        System.arraycopy(elemendData,index,elemendData,index+1,size-index);
        //3 数组元素的添加
        elemendData[index]=e;
        //4 数组size的+1
        size++;
    }

    /**
     * 获取某个位置上的元素
     * @param index list上的数组的位置
     * @return 获取到的元素
     */
    private E getValue(int index){
        return (E) elemendData[index];
    }

    /**
     * 移除list中某个位置的元素
     * @param index list的某个位置
     */
    private E remove(int index){
         List<String> list=new ArrayList<>();
        E oldValue= getValue(index);
        int numMoved=size-index-1;
        if(numMoved>0){
            System.arraycopy(elemendData,index+1,elemendData,index,numMoved);
        }
        elemendData[--size]=null;
        return oldValue;
    }

    /**
     * 移除list中的某个元素，传入的参数是object，数组中存的值
     * @param o
     */
    private Boolean remove(Object o){
        if(o==null){
            //如果o是空，怎么处理
            for (int i = 0; i < size; i++) {
                if(getValue(i)==null){
                    fastRemove(i);
                    return true;
                }
            }
        }else {
            //如果o不是空，怎么处理
            for (int i = 0; i < size; i++) {
                if(o.equals(getValue(i))){
                    fastRemove(i);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 在某个位置赋值新的值
     * @param index list的数组的位置
     * @param e 新的值
     */
    public void setNewValue(int index,E e){
        elemendData[index]=e;
    }

    private int getSize(){
        return elemendData.length;
    }

    /**
     * 快速删除元素
     * @param index
     */
    public void fastRemove(int index){
        int numMoved=size-index-1;
        if(numMoved>0){
            System.arraycopy(elemendData,index+1,elemendData,index,numMoved);
        }
        elemendData[--size]=null;
    }


    /**
     * 确保list的数组的容量可以容纳新增的元素
     * @param miniCapacity 添加新的元素后，list的数组的长度
     */
    public void ensureListCapacity(int miniCapacity){
        //1 先对数组的长度进行逻辑上的一些判断 得到目前需要定义的一个list数组的长度
        int nowCapacity=caculateCapacity(elemendData,miniCapacity);
        //2 如果新添加元素后，数组的长度大于目前数组定义的一个长度，则需要扩容
        if(nowCapacity-elemendData.length>0){
            grow(nowCapacity);
        }
    }

    /**
     * 计算目前的list的数组的定义的长度。1 如果是第一次初始化list，则有可能是默认的10，也有可能是初始化的时候有定义数组长度。
     *                              2 如果不是第一次初始化list，则直接返回的是目前数组的实际长度+1的值。
     * @param elemendData
     * @param miniCapacity
     * @return
     */
    public int caculateCapacity(Object[] elemendData,int miniCapacity){
        if(elemendData==DEFAULT_CAPACITY_ELEMENTDATA){
            return Math.max(DEFAULT_CAPACITY,miniCapacity);
        }
        return miniCapacity;
    }

    /**
     * 扩容的机制
     * @param nowCapacity 目前数组的实际的最大的长度
     */
    public void grow(int nowCapacity){
        //目前list的数组的定义的一个容量大小
        int oldGuiDing_Capacity=elemendData.length;
        //扩容为1.5倍后的容量大小
        int newGuiDing_Capacity=oldGuiDing_Capacity+(oldGuiDing_Capacity>>1);

        //比较，扩容后的容量大小是否是比实际数组的最大长度还小，如果还小，则将实际的数组的最大长度赋值给需要扩容的容量
        if(newGuiDing_Capacity-nowCapacity<0){
            newGuiDing_Capacity=nowCapacity;
        }

        //数据拷贝，产生一个新的数组，将旧的数组的数据拷贝到新的数组中去
        Arrays.copyOf(elemendData,newGuiDing_Capacity);
    }
}