JAVA中动态数组的定义扩容，添加元素，删除元素及各种遍历方法

1.数组

在计算机科学中，数组是由一组类型相同的元素（值或变量）组成的数据结构，每个元素至少有一个索引或键来标识；

在数组中所有的元素都是连续存储的，因此可以根据数组的起始地址计算出索引i元素的地址：

BaseAddress+i*size;

BaseAddress:起始地址；

i：元素索引（java中元素索引从0开始）

size：每个元素占用的字节（int 4个字节，double 8个字节，byte 1个字节）

2.基本操作

①添加元素

（1）在末尾直接添加；

（2）根据索引位置进行添加，找到要添加的索引让其后续元素依次后移，空出当前索引位置进行目标元素添加（借用java中的arraycopy（）方法）；

②查询元素

根据索引值查找，返回目标元素；

③遍历元素

（1）借助于Consumer<E> consumer遍历元素；

（2）使用迭代器Iterato遍历元素；

（3）使用IntStream stream()遍历元素；

④删除元素

根据索引删除目标元素，先找到索引所在位置的元素，然后依次让该索引之后的元素前移（借用java中的arraycopy（）方法）；

⑤数组扩容

改变数组容量，用新数组代替旧数组（借用java中的arraycopy（）方法）；

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

public class DyamArray implements Iterable<Integer>{
    private int size=0;//数组内元素个数
    private int capacity=8;//数组容量
    //private int [] array=new int[capacity];
    private int [] array= {};

    public void addLast(int element)     //在末尾增加元素
    {
        add(size,element);
    }
    public void add(int index,int element) //在任意索引位置增加元素
    {
        checkAndGrow();          //添加元素之前先判断是否需要进行扩容
        if(index>=0&&index<size)
        {
            System.arraycopy(array,index,array,index+1,size-index);
        }
        else {
            System.out.println("输入索引不合法！");
        }
        array[index]=element;
        size++;
    }
    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]);
        }
    }
    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()        //stream方式遍历元素
    {
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }
    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;
    }
    public void checkAndGrow()         //对数组进行扩容
    {
        if(size==0){
            array=new int[capacity];
        }
        if(size==capacity){
            capacity+=capacity>>1;     //扩大为原来的1.5倍
            int []newarray=new int[capacity];
            System.arraycopy(array,0,newarray,0,size);
            array=newarray;
        }
    }
}

3.时间复杂度

头部插入（或删除），时间复杂度为O(n);

中间插入（或删除），时间复杂度为O(n);

尾部插入（或删除），时间复杂度为O(n);

根据索引查找元素，时间复杂度为O(n);