ArrayList的源码分析

ArrayList的核心扩容机制分析

//minCapacity  所需要的最小容量  
 public void ensureCapacity(int minCapacity) {
        //如果elementData为空，使minExpand的值为默认容量10
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ?0
            : DEFAULT_CAPACITY;
        //如果最小容量大于minExpand
        //调用该方法判断是否需要扩容
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    //如果数组的容量为空，初始化数组容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

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

        // overflow-conscious code
        //调grow方法进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

 扩容的源代码分析：容量为扩容为原来的1.5倍

//oldCapacity 旧容量
//newCapacity 新容量
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;

        //新容量 = 1.5倍的旧容量

        int newCapacity = oldCapacity + (oldCapacity >> 1);

        //判断新容量是否小于最小容量，如果小于，将新容量更新为最小容量

        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;

        //判断新容量是否超出最大容量，如果超出，调hugeCapacity方法

        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);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();

        //最小容量大于最大容量的话，将最小容量更新为Integer.MAX_VALUE
        //否则，更新为MAX_ARRAY_SIZE
        //private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }