ArrayList 原理

基本属性

• Object[] elementData; 存放数据。
• int size; 存储的数据个数。
• int DEFAULT_CAPACITY = 10; 默认的容量（可存储数据的个数）
• Object[] EMPTY_ELEMENTDATA = {}; 空数组。
• Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 空数组。区别于EMPTY_ELEMENTDATA，改类型的数组，在第一次add数据时，会初始化elementData为默认容量10。
• transient int modCount = 0。该属性在父类AbstractList中。记录此列表在结构上被修改的次数。在iterator()和listIterator()中被使用，若迭代过程中，modCount被其它线程修改，则抛异常。

构造方法

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
        	// EMPTY_ELEMENTDATA 是一个空数组。
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
    
   public ArrayList() {
   		// DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是一个空数组。
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

常用方法

add

基本流程

• modCount++;
• 确保数组容量够用，不够则扩容。
• 添加数据。
• 返回 true。

源码解析

	public boolean add(E e) {
		// size 存储的数据个数，确保数组容量大于等于size+1;
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 添加 e
        elementData[size++] = e;
        return true;
    }

	private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    /** 计算容量
    * elementData 存储数据的数组
    * minCapacity size+1
    * */
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
    	// 若数组是默认的空数组，则从minCapacity 和 DEFAULT_CAPACITY（10）中取最大值。
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 若数组长度小于minCapacity，则扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

	private void grow(int minCapacity) {
        // minCapacity = size +1;
        int oldCapacity = elementData.length;
        // 新容量 = 原来的容量+原来的两倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 若新容量 < minCapacity, 则新容量=minCapacity。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 若新容量超出MAX_ARRAY_SIZE，则新容量 = MAX_ARRAY_SIZE。
        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);
    }

remove

基本流程

• 校验index是否越界。index必须小于size。
• modCount++。
• 获取该index对应的数据，需类型转换Object -> E，用于返回。
• 判断位于index之后的数据个数，若>0，则把index+1至size-1的数据前移1位。
• 最后一位赋值为null，等待GC。
• 返回 删除的数据（值）。

源码解析

public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);
		// numMoved=位于index之后的数据个数。若个数>0，则需把index+1至size-1的数据向前移1位。
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 最后一位赋值为null，等待GC。
        elementData[--size] = null; // clear to let GC do its work
        
        return oldValue;
    }