算法 数据结构数组，动态数组，动态数组扩容，手撸动态数组 ，数组实现自定义容器并实现扩容 数据结构（三）

 1. 由数组实现一个简单容器，并实现扩容

     建议看看arrayDeque源码，ArrayDeque 用数组实现的队列。采用head,tail参数，标记使用与添加的中间值。并实现了循环数组。 poll 方法消费队列数据，head会从中间部分值往后自增，poll 消耗完扩容前数据后，head归0，继续消费扩容后的数组部分。妙哉

package com.nami.algorithm.study.day03;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.Stream;

/**
 * beyond u self and trust u self.
 *
 * @Author: lbc
 * @Date: 2023-08-31 9:59
 * @email: [email protected]
 * @Description: keep coding
 */
public class DynamicArray<E> implements Serializable, Iterable, Cloneable {

    /**
     * 指针
     *
     * 【12, 23, null, null, null, null, null, null】
     * pointer    1
     */
    transient private int pointer;

    /**
     * 数组
     */
    transient private Object[] elements;

    /**
     * 数组容量
     */
    transient private int capacity;

    /**
     * 默认数组初始化容量
     */
    private static final int DEFAULT_SIZE = 8;

    public DynamicArray() {
        elements = new Object[DEFAULT_SIZE];
        this.capacity = DEFAULT_SIZE;
    }

    public DynamicArray(int size) {
        elements = new Object[size];
        this.capacity = size;
    }

    /**
     * 向容器内添加元素
     * 向最后一位添加数据
     * @param param
     */
    public void addLast(E param) {
        add(pointer, param);
    }

    public void add(int index, E param) {
        if (index > capacity) {
            throw new IndexOutOfBoundsException("数据超出容器范围");
        }
        // 动态扩容
        if (pointer >= capacity) {
            grow();
        }
        if (index >= 0 && index < elements.length) {
            System.arraycopy(elements, index, elements, index + 1, pointer - index);
        }
        elements[index] = param;
        pointer++;
    }

    /**
     * 数组扩容
     * 原数组的1.5倍
     */
    private void grow() {
        //  >> 防止/溢出 使用移位  （有符号位移）
        //  >>> 无符号位移
        capacity += capacity >> 1;
        Object[] temp = new Object[capacity];
        System.arraycopy(elements, 0, temp, 0, pointer);
        this.elements = temp;
        System.out.println("扩容成功, 当前size=" + capacity);
    }

    /**
     * 获取容器中元素值
     * @param index
     * @return
     * @param <E>
     */
    public <E> E get(int index) {
        if (index > capacity) {
            throw new IndexOutOfBoundsException("数据超出容器范围");
        }
        return (E) this.elements[index];
    }

    /**
     * 容器循环 lambda表达式
     * @param consumer
     */
    public void forEach(Consumer consumer) {
        // 去除数组内的null参数
        Object[] newArrays = Arrays.copyOfRange(elements, 0, pointer);
        for (Object element : newArrays) {
            consumer.accept(element);
        }
    }

    /**
     * 实现迭代器
     * @return
     */
    @Override
    public Iterator iterator() {
        return new Iterator() {
            int index = 0;

            @Override
            public boolean hasNext() {
                return index < pointer;
            }

            @Override
            public Object next() {
                return elements[index++];
            }
        };
    }

    /**
     * stream流
     * @return
     */
    public Stream stream() {
        return Stream.of(Arrays.copyOfRange(elements, 0, pointer));
    }

}