动态数组实现

```java
package com.demo._02动态数组;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * @create 2023/5/4 14:31
 * @Desc 动态数据实现
 * 实现 Iterable
 **/
public class _2DynamicArrayDemo implements Iterable<Integer>{

    // 逻辑大小
    private int size = 0 ;
    // 容量
    private int capacity = 8 ;
    private int[] array = {};

    /**
     * 添加元素到最后
     * @param elemnent
     */
    public void addLast(int elemnent) {
        add(size, elemnent);
    }

    /**
     * 添加元素到指定位置
     * @param index
     * @param elemnent
     */
    public void add(int index, int elemnent) {

        // 扩容代码
        checkAndGrow();

        // 判断边界
        if(index >= 0 && index <= size) {
            // 数组之间元素的复制和交换
            // 参数1 要复制的数组，参数2 复制的起始位置， 参数3 目标数组， 参数4 目标数组起始位置， 参数5 复制多少个元素
            System.arraycopy(array, index, array, index+1, size - index);
        }
        array[index] = elemnent ;
        size ++ ;
    }

    /**
     * 数组扩容
     */
    private void checkAndGrow() {
        // 容量检查

        if(size == 0) {
            array = new int[capacity] ;
        }else if(size == capacity) {
            // 进行扩容，扩容1.5倍, 1.5 1.618 2
            capacity += capacity >> 1 ;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0 ,newArray, 0, size);
            array = newArray ;
        }
    }

    /**
     * 根据索引获取元素
     * @param index
     * @return
     */
    public int get(int index){
        return array[index] ;
    }

    /**
     * 遍历方法1
     * @param consumer 函数式接口参数
     */
    public void forEachTest(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            // 提供array[i]处理
            consumer.accept(array[i]);
        }
    }

    /**
     * 遍历方法2-迭代器遍历
     * @return
     */
    @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++];
            }
        };
    }

    /**
     * 遍历方法3-stream流
     * @return
     */
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size)) ;
    }

    /**
     * 删除元素
     * @param index
     * @return
     */
    public int remove(int index) {
        int removed = array[index] ;
        if(index < size -1) {
            System.arraycopy(array , index+1, array, index, size - index -1);
        }
        size-- ;
        return removed ;
    }

    /**
     * 实现Iterable的遍历数组
     * @param action
     */
    @Override
    public void forEach(Consumer<? super Integer> action) {
        Iterable.super.forEach(action);
    }

    public static void main(String[] args) {

        _2DynamicArrayDemo dynamicArrayDemo = new _2DynamicArrayDemo();
        dynamicArrayDemo.addLast(1);
        dynamicArrayDemo.addLast(2);
        dynamicArrayDemo.addLast(3);
        dynamicArrayDemo.addLast(4);
        dynamicArrayDemo.addLast(5);
        dynamicArrayDemo.addLast(6);
        dynamicArrayDemo.addLast(7);
        dynamicArrayDemo.addLast(8);
        dynamicArrayDemo.addLast(9);
        dynamicArrayDemo.addLast(10);

        // System.out.println(dynamicArrayDemo.remove(3));
        System.out.println("-----------------------------------");
        dynamicArrayDemo.stream().forEach(ele -> System.out.println(ele));


    }
}