ArrayList的源码

1、ArrayList的空构造方法

	//空的Object数组
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
	//空构造方法默认一个空的Object数组
 	public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

注意：对于ArrayList空的构造方法，在赋值的时候才会去给数组分配容量。不是构造ArrayList对象的时候就会分配容量。
2、ArrayList的带参数构造方法

	//带参数构造
 	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);
        }
   }

注意：根据参数的容量去构建Object数组的容量。
3、ArrayList的扩容方法

	//添加元素
 	public boolean add(E e) {
        modCount++; //记录操作次数
        add(e, elementData, size); //size是ArrayList的元素个数
        return true;
    }
    
     private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)//当数组的长度等于ArrayList的长度时候扩容
            elementData = grow();
        elementData[s] = e; //将新加的元素放入数组
        size = s + 1;//ArrayList的长度加一
    }
    
	private Object[] grow(int minCapacity) {
		//扩容并将原数组内容复制到新数组里面
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));                          
    }

 	  private Object[] grow() {
        return grow(size + 1); //ArrayList的长度加一作为扩容的最小容量
    }
   	private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length; //原数组长度
        //（扩容机制）数组长度增加到原来1.5倍，oldCapacity右移1位，相等于除以2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity <= 0) {
        	//当是空构造的时候数组，取值默认容量DEFAULT_CAPACITY 10
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            //最小容量小于0，内存溢出，抛出异常
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        //当新容量小于等于数组的最大容量的时候，返回新容量，否则去取MAX_ARRAY_SIZE或者	Integer.MAX_VALUE									
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }
    
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //最小容量大于MAX_ARRAY_SIZE， 返回Integer.MAX_VALUE，否则返回MAX_ARRAY_SIZE
     private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE)
            ? Integer.MAX_VALUE
            : MAX_ARRAY_SIZE;
    }

主要是ArrayList的扩容方法比较难理解一点，看源码基本的思路可以看懂。空构造的初始数组容量是10，后面会按照1.5倍去扩容，依次是15,22,33…,有参构造会根据填入的参数值进行1.5的扩容。