【转载】ArrayList从源码看扩容实现

public class ArrayList<E> extends AbstractList<E> implements List<E>, 
RandomAccess, Cloneable, java.io.Serializable

ArrayList类继承自抽象类AbstractList，实现了List接口，随机存取RandomAccess接口，克隆接口Cloneable，序列化接口Serializable。

通常，我们使用Arraylist添加一个对象往往无需过多考虑，直接add()即可，无需担心其容量是否超过限制，其原因就在于Arraylist源码中，实现add()方法之前会查看其容量是否够用，不够则会自动‘扩容’然后再执行add()添加元素，即自动扩容。

让我们从一个空的数组列表添加元素开始，看一下源码是如何实现的。

List list = new ArrayList();
list.add("A");

首先，List list = new ArrayList();初始化了一个空数组列表list，具体是ArrayList类源码中：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
private int size;

初始化ArrayList对象的同时创建了一个默认为空的Object数组变量elementData。然后list.add("A")对应的是源码中的add()方法：

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

如图中所示，public boolean add(E e){}方法会执行modCount++;然后调用add(e,elementData,size)方法，最后返回布尔类型的ture。

modCount在ArrayList中定义如下：

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

doc说明：

/**
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results....

很多结构化地改变数组的操作都会用到modCount计数，用来标识数组被修改的次数。譬如add , set , remove等。

由于是初次添加元素，故modCount++后变为1，来到下一步add(e, elementData, size)，此时e为要添加的元素：“A”，elementData为刚刚创建的Object[], size为数组初始容量，值为0(在ArrayList中定义：private int size，int型初始未赋值则为0)

重点看下add方法的具体实现：

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

由于初始elementData.length==size==0故执行grow()方法，返回值赋给elementData。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    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);
}

grow有两个重载的方法，无参的grow()会调用有参的grow，参数为size+1。

private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData, newCapacity(minCapacity));
    }

此处size+1=1作为minCapacity，表示最小容量，实际也很好理解，因为add一个对象首先我需要的最小容量是原长度+1，有了最小容量才能进行下一步地添加元素操作，所以通过grow()来确保我arraylist对象的长度，即【扩容】

扩容的操作通过Arrays.copyOf方法实现：

public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

此方法直接将原数组elementData复制到一个新的给定长度的数组中，并返回此新数组对象。

那么新数组长度是多少呢？这个就是newCapacity()中定义的，让我们看一下：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

http://1.int oldCapacity = elementData.length

此处由于elementData是空数组，所以oldCapacity==elementData.length==0

2.newCapacity = oldCapacity + (oldCapacity >> 1)

这一步是扩容的核心操作，即扩容后新数组的长度=原数组的容量+原数组的容量/2.

通过oldCapacity >> 1(Java移位运算，右移1位相当于除以2)来实现扩容原数组容量的一半

，即ArrayList的扩容是根据原容量的1.5倍来扩容的。

但是此时oldCapacity值为0故newCapacity也为0，扩容无效...

3.if(newCapacity - minCapacity <=0)

经过第二步后的newCapacity=0，小于minCapacity=1故进入下面的步骤：

public static native void arraycopy(Object src,  int  srcPos,   Object dest, int destPos,  int length);

4.return Math.max(DEFAULT_CAPACITY, minCapacity);

DEFAULT_CAPACITY为ArrayList中初始的默认容量，大小为10。定义如下：

return Math.max(DEFAULT_CAPACITY, minCapacity)返回10和minCapacity中的最大值，此处直接返回10

现在，经过newCapacity()计算后的新数组容量为10，让我们回到grow()中的：

Arrays.copyOf将elementData复制到一个容量为10的新Object[]中去，并返回此数组对象elementData，完成了前面一大堆准备工作，并执行扩容后，终于来到了add()方法中的最后两步：

elementData[s] = e;

完成新增元素添加

size = s + 1;

将该ArrayList对象的数量+1

 

转载于:https://www.cnblogs.com/smallwangmusk/p/11421232.html