数组动态扩容

数组介绍

数组是一种顺序存储的线性表，可以存储多个值，每个元素可以通过索引进行访问，所有元素的内存地址是连续的。

优点：

空间利用率较高。
查询速度高效，通过下标来直接存取。

缺点：

插入和删除比较慢，插入删除都需要遍历数组；
不可以增长长度，有空间限制,当需要存取的元素个数可能多于顺序表的元素个数时,会出现"溢出"问题.当元素个数远少于预先分配的空间时,空间浪费巨大。

实例：

//输入：[0,1,0,3,5]
        int[] nums = {0,1,0,3};//原来数组长度为4
        System.out.println("原始数组长度"+nums.length);
        int[]newsNew = new int[nums.length+(nums.length>>1)];//新建数组长度为原数组长度的1.5倍
        for(int i=0;i<nums.length;i++){//遍历的方法把原数组数据复制到新的数组
            newsNew[i] = nums[i];
        }
        nums = newsNew;//将新数组命名为原数组
        System.out.println("扩容后数组长度"+nums.length);

数组动态扩容：

public class DynamicArray <E>{
    private int size = 0;
    private  static  final  int DEFAULT_CAPACITY=10;
    private  static  final  int ELEMENT_NOT_FOUND = -1;
    private E[] elements = (E[]) new Object[DEFAULT_CAPACITY];

    public DynamicArray() {
        this(DEFAULT_CAPACITY);
    }
    /**
     * 带参初始化
     * @param capacity 初始化容量
     */
    public DynamicArray(int capacity) {
        if(capacity < 10){
            elements= (E[]) new Object[DEFAULT_CAPACITY];
        }else{
            elements = (E[]) new Object[capacity];
        }
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public boolean contains(E element){
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    public int indexOf(E element){
        if(element == null){
            for(int i=0;i<size;i++){
                if(elements[i] == null){
                    return  i;
                }
            }
        }
        else{
            for(int i=0;i<size;i++){
                if(element.equals(elements[i]) ){
                    return i;
                }
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    public E get(int index){
        checkIndex(index);
        return  elements[index];
    }

    public E set(int index,E element){
        checkIndex(index);
        E old = elements[index];
        elements[index] = element;
        return  old;
    }

    public void clear(){
        for (int i=0;i<size;i++){
            elements[i] = null;
        }
       size=0;
    }
    public int size(){
        return size;
    }
    public void add(E element){
        if(size>elements.length-1){
            System.out.println("开始扩容");
            ensureCapacity(size+1);
        }
        elements[size] = element;
        size++;
    }
    public void add(int index,E element){
        if(index<0 || index>size){
            throw new IndexOutOfBoundsException("索引越界，允许范围size:0=>"+(size)+"当前索引："+index);
        }
        for(int i=size;i>index;i--){
            elements[i] = elements[i-1];
        }
        elements[index]=element;
        size++;
    }

    public E remove(int index){
        checkIndex(index);
        E old = elements[index];
        for(int i=index;i<size;i++){
          elements[i] = elements[i+1];

        }
        size--;
        elements[size]=null;
        //判断是否缩容
        if(size==elements.length>>1){
            System.out.println("开始缩容");
            ensureCapacity(elements.length>>1);
        }
        return old;

    }

    public void ensureCapacity(int capacity){
        if(elements.length>=capacity){
            return;
        }
        //扩容1.5倍
        E[] newElements = (E[]) new Object[elements.length+(elements.length>>1)];
        for(int i=0;i<size;i++){
            newElements[i] = elements[i];
        }
        elements = newElements;

    }


    public  void  checkIndex(int index){
        if(index<0 || index>=size){
            throw new IndexOutOfBoundsException("索引越界，允许范围size:0=>"+(size-1)+"当前索引："+index);
        }
    }

    @Override
    public String toString() {
        return "DynamicArray{" +
                "size=" + size +
                ", elements=" + Arrays.toString(elements) +
                '}';
    }
}