public class DynamicArray implements Iterable<Integer>
{
    private int size = 0; // 逻辑大小
    private int capacity = 8; // 容量
    private int array[] = {};

    /**
     * 向最后位置[size]添加元素
     * @param element 待添加元素
     */
    public void addLast(int element)
    {
        add(size, element);
    }

    /**
     * 向[0 ... size] 位置添加元素
     * @param index 索引位置
     * @param element 待添加元素
     */
    private void add(int index, int element)
    {
        // 检查是否需要扩容
        checkAndGrow();
        // 如果index 小于等于 0 或 小于 size 就满足条件
        // 如果是 直接调用 add 想要在 某个元素后面添加元素就会满足条件
        if(index >= 0 && index < size)
        {
            // 从 index 索引开始 拷贝 到 index + 1 ，需要的长度为 size - index
            // 从 某个元素的位置开始 整体向后移动一位 下面再对当前索引位置进行赋值并扩大容量
            System.arraycopy(array, index, array, index + 1, size - index);
        }
        // 将值赋值到index处
        array[index] = element;
        // 数组容量扩大
        size++;
    }

    private void checkAndGrow()
    {
        if(size == 0)
        {
            array = new int[capacity];
        }else
        // 判断如果size 等于了 capacity 就进行扩容
        if(size == capacity)
        {
            capacity += capacity >> 1;
            // 创建扩容后的数组
            int newArray[] = new int[capacity];
            // 将旧数组中的元素拷贝到新数组中
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
        }
    }

    /**
     * 查询元素
     * @param index 索引位置，在[0 ... size] 区间内
     * @return 该索引位置的元素
     */
    public int get(int index)
    {
        return array[index];
    }

    public void foreach(Consumer<Integer> consumer)
    {
        for(int i = 0; i < size; i++)
        {
            consumer.accept(array[i]);
        }
    }

    @Override
    public Iterator<Integer> iterator()
    {
        return new Iterator<Integer>()
        {
            int i = 0;
            @Override
            public boolean hasNext() // 有没有下一个元素
            {
                return i < size;
            }

            @Override
            public Integer next() // 返回当前元素, 并移动到下一个元素
            {
                return array[i++];
            }
        };
    }

    public IntStream stream()
    {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));
    }

    public int remove(int index)
    {
        int i = array[index];
        if(index < size - 1)
        {
            System.arraycopy(array, index + 1, array, index, size - index - 1);
        }
        size--;
        return i;
    }

    public static void main(String[] args)
    {
        DynamicArray dynamicArray = new DynamicArray();
        dynamicArray.addLast(1);
        dynamicArray.addLast(2);
        dynamicArray.addLast(3);
        dynamicArray.addLast(4);
        dynamicArray.stream().forEach(e -> {
            System.out.println(e);
        });
    }
}