数组的动态扩容以及缩容

数组

数组（Array）是一种线性表的数据结构，是一组连续的存储空间(区别于链表，不连续)用来存储相同类型的数据。

连续的内存空间
数组在内存中的存储方式是一组给定长度的连续的空间。
连续的空间才使得数组可以实现通过下标随机访问。
java中常用的list集合，例如ArrayList，底层就是用数组实现的，最底层的数据初始化的时候就已经指定好了该数组的长度。

特点
可以直接随机访问(依据下标访问)其中的任意数据
随机访问数据非常高效
低效的插入和删除

我们在使用ArrayList时，在不了解数据个数的情况下，有时并不会去初始化具体的长度（最好是限定长度），而底层又是数组实现，那么它是如何实现的呢，这就涉及到了一个数组的动态扩容和缩容机制。

增加：

/**
 * 添加元素
 * @param elememt
 */
public void addElement(int index,T elememt){
    if(index < 0 || index >size){
        throw new IllegalArgumentException("add Failed,indexOutException");
    }
        // 扩容
        reSize(size);
     for(int i = size -1 ,in = index-1;i>in;i--){
        data[i+1] = data[i];
    }
        data[index] = elememt;
     size++;
}

删除：

public T remove(int index){
    if(index < 0 || index >size){
        throw new IllegalArgumentException("add Failed,indexOutException");
    }
    T element  = data[index];
    for(int i = index,in = size -1;i<in;i++){
        data[i] = data[i+1];
    }
    size--;
    reSize(size);
    return element;
}

扩容以及缩容

/**
 * 扩容以及缩容
 * @param v
 */
private void reSize(int size) {
    // 三种扩容方式
    if(size+1 > data.length){
        T[] temp = (T[])new Object[size*2];
       for(int i = size-1,in = 0;i>=in;i--){
            temp[i] = data[i];
        }
      //  System.arraycopy(data,0,temp,0,data.length);
      //  T[] temp = java.util.Arrays.copyOf(data,size*2);
        data = temp;
    }

    if(size<= data.length/4 && data.length/2!=0){
        T[] temp = (T[])new Object[data.length/2];
        for(int i = size-1,in = 0;i>=in;i--){
            temp[i] = data[i];
        }
        data = temp;
    }

}

涉及到数组的三种扩容方式

T[] temp = (T[])new Object[size*2];
for(int i = size-1,in = 0;i>=in;i--){
      temp[i] = data[i];
  }
//  System.arraycopy(data,0,temp,0,data.length);
//  T[] temp = java.util.Arrays.copyOf(data,size*2);
  data = temp;

对于为啥要设置为1/4，而不是1/2，这个是为了避免出现一个现象，即复杂度震荡
复杂度震荡
（1）在对数组的缩容和扩容的操作时，如果操作不当，容易造成复杂度震荡的问题。
（2）什么情况下会出现复杂度震荡？
例如当数组的容量为10，当数组的数据等于10时，添加第11位数据时，需要扩容，容量为20；那么扩容的复杂度为O(n)；
接着对11位的数据进行删除，那么数组的剩余空间为10，那么要缩容到之前空间的一半；那么缩容的复杂度为O(n)；
那么如果一直对第11位数进行操作的话，那么复杂度一直保持在0（n）上。
简而言之 remove元素的时候触发缩容，然后add元素又进行了扩容，然后又去调remove方法，又触发缩容…往复循环。
如何避免呢？
扩容的倍数 与 缩容的倍数相乘不等于1 时，就可以避免这个问题。

数组插入操作：如果我们要插入的数组是一个本身就无序的数组，那么我们可以不需要将数据插到指定位置，直接插入末尾即可，这样时间复杂度为O(1)，效率极高。
数组删除操作：如果我们有需求涉及到频繁的删除数组中的数据，因为每次删除都会造成数据的移动，非常的消耗性能，我们可以先记录下已经删除的数据，而不是真正的从数组中删除，当数组空间不够时或者删除操作全部执行完之后，再一次性的删除全部对应的数据并移动剩余数据，这样大大减少了数据 搬移的次数，提高执行效率。（这也是JVM标记清除垃圾回收算法的核心思想）