ArrayList的底层和扩容

对ArrayList的理解

此文为参考javaguide所提供的面试题，从中总结，如想了解详情，请点击链接
javaguide

1.简介

ArrayList是List的实现类，它的底层是用Object数组存储，线程不安全

适合用于频繁的查询工作，因为底层是数组，可以快速通过数组下标进行查找。

2.ArrayList与LinkedList的区别（5个方面）

1.他们都是线程不安全的。

2.ArrayList底层是object数组，linkedlist底层是使用双向链表。

3.ArrayList是采用数组存储，所以插入和删除元素的时间复杂度受元素位置影响。add方法将指定的元素添加到列表的末尾，为O（1）。在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i) 。linkedlist是使用双向链表的，所以插入和删除元素的时间复杂度受不受元素位置影响。在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n)需要移动到指定的位置在插入。

4.ArrayList可以快速随机访问，它实现了RandomAccess接口（RandomAccess这个接口是标记接口，实现它代表该结构支持快速随机访问）。linkedList不支持。

5.内存占用情况：A 浪费空间体现在它的底层是数组所以要在末尾预留一定容量的空间。L的每一个元素占用的空间都比A的多，因为是双向链表（存在前继和后继以及数据）

线程安不安全，底层数据结构，插入和删除的时间复杂度，快速随机访问，内存占用

3.ArrayList源码的理解

6个参数

 private static final long serialVersionUID = 8683452581122892189L;
/**
 * 默认初始容量大小
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 空数组（用于空实例）。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

 //用于默认大小空实例的共享空数组实例。
  //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 保存ArrayList数据的数组
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * ArrayList 所包含的元素个数
 */
private int size;

3个构造方法

一个带初始容器参数的构造函数，一个默认构造函数，一个包含指定集合的元素的集合。

需要注意默认构造函数（this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;）*实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10

/**
     * 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //如果传入的参数大于0，创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //如果传入的参数等于0，创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //其他情况，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
/**
 *默认无参构造函数
 *DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
 */
public ArrayList(Collection<? extends E> c) {
    //将指定集合转换为数组
    elementData = c.toArray();
    //如果elementData数组的长度不为0
    if ((size = elementData.length) != 0) {
        // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
        if (elementData.getClass() != Object[].class)
            //将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 其他情况，用空数组代替
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

4.ArrayList的扩容机制

四个方法

ensureCapacityInternal(size + 1);

ensureExplicitCapacity(minCapacity);

grow(minCapacity)；

hugeCapacity()；

/**
     * 将指定的元素追加到此列表的末尾。
     */
    public boolean add(E e) {
   //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }

（1）用到一个方法ensureCapacityInternal(size + 1); 此方法是为了得到最小容量

//得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

当 要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，DEFAULT_CAPACITY默认为10，所以minCapacity 为 10。

（2）此方法中==用到另外一个方法 ensureExplicitCapacity(minCapacity);==此方法为判断是否需要扩容。

  //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }

（3）此方法中有另外一个方法grow(minCapacity)，核心扩容方法

当要add进第一个元素的到ArrayList中，elementData.length为0，还是一个空列表，因为执行了ensureCapacityInternal()方法中minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); 所以minCapacity 此时为10，此时minCapacity - elementData.length > 0所以会进入grow(minCapacity); 该方法是扩容方法，调用此方法代表已经开始扩容了。

当add进第二个元素，minCapacity为2，此时 e lementData.length(容量)在添加第一个元素后扩容成 10 了所以minCapacity - elementData.length > 0不成立，不会进入到grow方法。以此类推一直到添加到第11个元素。

当add到第11个元素minCapacity为11,minCapacity - elementData.length > 0成立,会再次进入到grow方法进行扩容。

 /**
     * 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
       // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

int newCapacity = oldCapacity + (oldCapacity >> 1)相当于每次扩充都扩充之前的1.5倍左右。 (oldCapacity >> 1)相当于1/2倍的oldCapacity。右移一位>>1相当于除2.>>n相当于除2的n次方。位运算比普通运算高效的多。

总结grow方法

当add第一个元素是，oldCapacity 为 0，经过==(newCapacity - minCapacity < 0)判断newCapacity = minCapacity(为 10)。默认初始容量大小为10，接着判断if (newCapacity - MAX_ARRAY_SIZE > 0)不成立，则不会进入到hugeCapacity(minCapacity);==数组容量为10，返回true，size+1；

当add第11个元素进入grow方法，newCapacity=15，比minCapacity（11）大，第一个if不成立，newCapacity不大于数组最大size，还是不会进入到hugeCapacity(minCapacity)方法。数组容量扩容为15.返回true，size增为11.

（4）会调用hugeCapacity() 方法

当newCapacity大于MAX_ARRAY_SIZE时才会执行。当==(minCapacity > MAX_ARRAY_SIZE)==成立数组大小为Integer.MAX_VALUE，如果不成立数组大小为Integer.MAX_VALUE-8

在扩容中，经常使用的两个方法。

System.arraycopy()方法

    /**
 * 在此列表中的指定位置插入指定的元素。
 *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
 *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //arraycopy()方法实现数组自己复制自己
    //elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

Arrays.copyof()方法,主要是为了给原有的数组进行扩容。

  /**
     以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
     */
    public Object[] toArray() {
    //elementData：要复制的数组；size：要复制的长度
        return Arrays.copyOf(elementData, size);
    }

两者区别

toArray方法中调用了System.arraycopy()方法；

arraycopy()需要目标数组，将原数组拷贝到你自定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置

copy()是系统自动在内部新建一个数组，并返回数组。

ensureCapacity方法

此方法是提供给用户调用的

ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以减少增量重新分配的次数。

/**
如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
 *
 * @param   minCapacity   所需的最小容量
 */
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}