容器——ArrayList的源码分析（JDK1.8）

1.入口

public class ListTest {
    public static void main(String[] args) {
        //创建
        ArrayList<Integer> list = new ArrayList<>();
        //执行add操作
        list.add(1);
    }
}

2.创建（构造器及初始参数）

//无参构造器，创建时调用,此时DEFAULTCAPACITY_EMPTY_ELEMENTDATA为长度是0 的Object[]
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
//底层为Object[]，且初始长度为0
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

3.执行add操作

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

//本例中，minCapacity=0+1=1;
private void ensureCapacityInternal(int minCapacity) {
	        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
	    }
/*1.判断所需容器的容量*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
			//如果是第一次，即缓冲数长度为0，那么判断默认值DEFAULT_CAPACITY 10和minCapacity大小，返回较大的那一个
	        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
	            return Math.max(DEFAULT_CAPACITY, minCapacity);
	        }
	        //其余情况直接返回minCapacity（即存储此数组，需要的最小的容量）
	        return minCapacity;
	    }
	    
//此数据代表缓冲数组，或者叫中间数组
transient Object[] elementData; 
//默认容量
private static final int DEFAULT_CAPACITY = 10;

/*2.扩容方法*/
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
private void grow(int minCapacity) {
        //现在的容量
        int oldCapacity = elementData.length;
        //按照1.5倍扩容
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //判断扩容之后是否足够，取较大值
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //判断扩容之后是否超标
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 复制原来的数组元素到扩容在之后的数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
//判断扩容之后是否超标，如果超标，最大也只能是Integer的最大值
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

4.总结

4.1 ArrayList list = new ArrayList();//底层只是做一个声明,并不创建

4.2 list.add(1);//此时底层创建了长度10的Object[]数组elementData，并将数据1添加到elementData[0]，如果此次的添加导致底层elementData数组容量不够，则扩容，默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。