ArrayList擴容

jdk1.5

    public ArrayList(int initialCapacity) {
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    this.elementData = (E[])new Object[initialCapacity];
    }

可以看出，如果在初始化ArrayList時進行賦值，那么開始是不會進行擴容的。

如果是一個未賦值初始值的ArrayList,不斷對其進行add，那么可以看出再超過oldCapacity的時候，會生成新的newCapacity,值是（oldCapacity*3）/2+1。

   public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
        elementData = (E[])new Object[newCapacity];
        System.arraycopy(oldData, 0, elementData, 0, size);
    }
    }

可以非常明顯的看出，在新增到11個元素的時候，ArrayList內部的elementData數組變成了16個長度的數組。

17時變成25

26時變成38

39時變成58

。。。。

如果開始賦值為2，那么分別也會擴容2,4,7,11.。。。。。

====================================

JDK1.7在新增時擴容：

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

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    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);
    }

>>位運算，右移動一位。 整體相當於newCapacity =oldCapacity + 0.5 * oldCapacity
jdk1.7采用位運算比以前的計算方式更快。

 

http://blog.csdn.net/u010176014/article/details/52073339