ArrayList源码全面详细分析

昨天在公众号看了一篇 LinkedList源码分析
非常感兴趣，于是又自己研究了一下ArrayList的源码。
本文的两个固定用词：
容量：集合中数组的length
大小：集合的size

1.常量

 	/**
     * 默认初始容量 10
     */
    private static final int DEFAULT_CAPACITY = 10;
    
    /**
     * 空数组，初始化和赋值为空数组的时候使用
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 空数组，初始化和判断的时候使用
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * ArrayList实际存储容器：object数组
     */
    transient Object[] elementData; 

    /**
     * ArrayList的大小，不一定等于容量
     */
    private int size;

从以上属性可看出
①arraylist底层是object数组:Object[] elementData
②arraylist初始大小10

2. 构造方法

    /**
     * 指定size, ArrayList = new Object[initialCapacity]
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     * 不指定size，ArrayList = 空数组
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 指定初始集合
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

从以上属性可看出
①arraylist提供了3种构造方法
②arraylist初始化时已经指定了其容量，容量不可变，arraylist实现size可变实际是通过其grow方法，运用了Arrays.copyOf 复制数组来扩容。（下文会提到）

3.add方法

  /**
     * 新增元素
     */
    public boolean add(E e) {
    	//1.检查是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //2.末位赋值新增元素，size加1
        elementData[size++] = e;
        return true;
    }

    /**
     * 指定位置新增元素
     */
    public void add(int index, E element) {
    	//1.检查是否数组越界
        rangeCheckForAdd(index);
		//2.检查是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //3.index后的元素集体后移一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        //4.index位置赋值新增元素                 
        elementData[index] = element;
        //5.size加1
        size++;
    }
    
   /**
    * 新增集合元素
    */
     public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        //1.检查是否需要扩容
        ensureCapacityInternal(size + numNew);  // Increments modCount
        //2.把源数组从0开始复制到目标数组elementData从size开始，复制元素数量为numNew
        System.arraycopy(a, 0, elementData, size, numNew);
        //3.size加numNew
        size += numNew;
        return numNew != 0;
    }

    /**
     * 指定位置新增集合元素
     */
    public boolean addAll(int index, Collection<? extends E> c) {
    	//1.检查是否数组越界
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        //2.检查是否需要扩容
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        //3.不是末位新增，则index后的元素集体后移numNew位
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
		//4.把源数组从0开始复制到目标数组elementData从index开始，复制元素数量为numNew
        System.arraycopy(a, 0, elementData, index, numNew);
        //5.size加numNew
        size += numNew;
        return numNew != 0;
    }

关于检查是否需要扩容的方法如下

	/**
	 * 检查是否需要扩容
	 */
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

	/**
	 * 判断：集合为空集，则返回默认初始容量10
	 */
 	private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

	/**
	 * 检查是否需要扩容
	 */
    private void ensureExplicitCapacity(int minCapacity) {
    	//1.集合修改次数加1
        modCount++;
        //2.所需容量超过当前容量，则扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    /**
	 * 集合扩容
	 * minCapacity：目标容量
	 */
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //1.对当前容量加一半，得到新容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //2.加一半后仍小于目标容量，则新容量 = 目标容量 
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //3.elementData复制到新数组，新数组长度为目标容量
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

从扩容方法可看出
①new arraylist() 其内部是一个长度为0的数组
②对新建空集合调用add，必定会扩容，扩容完容量为10, size = 1
对size>0集合调用add，size + 1 > arrLength 会扩容，如果arrLength<10 ,扩容完容量为10 和 arrLength1.5 后的较大值；如果 arrLength>=10,扩容完容量为arrLength1.5后向下取整

4.get/set方法

	/**
	 * 获取指定位置元素
	 */
    public E get(int index) {
    	//1.检查是否数组越界
        rangeCheck(index);
		//2.返回数组指定位置元素
        return elementData(index);
    }
    /**
	 * 替换指定位置元素
	 */
    public E set(int index, E element) {
    	//1.检查是否数组越界
        rangeCheck(index);	
        E oldValue = elementData(index);
        //2.替换数组指定位置元素
        elementData[index] = element;
        //3.返回该位置旧元素
        return oldValue;
    }

发现两个有趣的方法 trimToSize / replaceAll

	/**
	 * 使集合 容量=大小,减少实例存储，释放空间
	 */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }
	/**
	 * 用operator运算的结果替换集合中的每个元素
	 * UnaryOperator是Function的一个继承接口，从 operator.apply 也能看出
	 */
    @Override
    @SuppressWarnings("unchecked")
    public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

5.remove方法

	/**
	 * 删除指定位置元素
	 */
 	public E remove(int index) {
 		//1.检查是否数组越界
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);
		//2.判断是否末位删除，不是则index+1之后的元素集体前移一位
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //3.末位元素设为null
        elementData[--size] = null;
        return oldValue;
    }

	/**
	 * 删除指定元素
	 * 正向边理，找到该元素位置，再调用删除指定位置元素
	 */
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
    
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

removeAll 和 retainAll 可以联合起来看

	/**
	 * 删除集合c中包含元素
	 */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }
    /**
	 * 保留集合c中包含元素，删除其他元素
	 */
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }
	
	/**
	 * 核心逻辑，如果c包含/不包含当前数组元素，则加入当前数组，从0位开始赋值
	 * 然后把w位之后的元素置为null
	 */
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

关于ArrayList还有很多方法：clear,clone,contains,indexOf,ensureCapacity,isEmpty,sort等，逻辑都挺简单
还需要分析的有 iterator，ListIterator 和 subList 这两部分，其中subList是经常踩坑的地方，感兴趣的小伙伴可以自行研究。
以上，谢谢阅读！