ArrayList的基本工作原理详解add

ArrayList其实就是一个长度可变的数组，看源码就是知道，就是是一个Object[]。 
ArrayList是unsynchronized。 
因为底层由数组承载，那么需要连续的内存空间，所以空间复杂度是O(n)。 
如果按下标直接去get(index)或者直接add(e)到数组的尾部，那么时间复杂度是O(1)。 
如果要remove(index),或者add(index,e)那么时间复杂度为O(n)。 
接下来看一下源码

  /**
     * 默认初始容量空间为10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空的Object数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * add存储的数组
     */
    private transient Object[] elementData;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

首先来说实例化 
ArrayList(int initialCapacity)； 
实例化可以直接给出数组的长度，虽然数组可以自己扩容，但是扩容需要过程的空间复杂度应该是O(2n)因为需要拷贝一个次旧的数组。这个在后面会提到。所以当确定数组大小的时候，比如或limit确定了取多少数据，那么请直接给list固定的长度。 
如果用下面的够早进行实例化，那么初始的底层数组是一个null,是没有长度的。

 public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

• 1
• 2
• 3
• 4

接着看 add(),第一步先做了增量的变化

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

• 1
• 2
• 3
• 4
• 5

然后进入ensureCapacityInternal()方法

 private void ensureCapacityInternal(int minCapacity) {
        //如果说数组没有长度的话，需要进行长度赋值
        //第一次操作数组的话Math.max(10,1)
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //此时minCapacity = 10传入ensureExplicitCapacity()
        ensureExplicitCapacity(minCapacity);
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

再看ensureExplicitCapacity()方法

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

        // 如果说add后的长度大于现有的数组长度,说明数组应该扩容了。
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7

进入grow();

 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
        // 先获得旧数组的长度
        int oldCapacity = elementData.length;
        //通过右移1位来实现oldCapacity/2,扩容原来的1.5倍(PS.左移一位*2，右移一位/2)
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果新的容量可以放下准备add后的容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新扩容后大于Integer.MAX_VALUE - 8，抛出OutOfMemoryError
        //为什么会-8？javadoc说需要保留一些做head
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //确定了新的容量后，拷贝，new 新的长度的数组，在赋值 
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

虽然List是一个可变数组，但是可变是付出了空间的代价。所以，根据实际情况去运用。

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u013177381/article/details/72236800