ArrayList

ArrayList只写add方法了，其他的方法感兴趣的自己看一下，都比较简单。

构造函数

public ArrayList(int initialCapacity) {
        // 如果初始容量大于0，则创建一个initialCapacity大小的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            // 初始容量等于0，则用初始数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

// 无参构造函数，用默认数组，并且默认的的容量是10
 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

public ArrayList(Collection c) {
       // elementData被赋值为元素数组
        elementData = c.toArray();
       // 元素个数(size)被赋值为elementData的长度
        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;
        }
    }

添加元素

需要的常量

   // 默认数组
   private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    
   // 默认容量
   private static final int DEFAULT_CAPACITY = 10;
   // 数组的最大容量
   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

 public boolean add(E e) {
        // 调整容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 调整完容量加入元素
        elementData[size++] = e;
        return true;
    }


 // 调整容量
 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

// 计算添加元素所需要的最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
         // 如果是第一次add，则返回默认容量和当前minCapacity的最大值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
      // 若不是第一次add，则返回minCapacity
        return minCapacity;
    }

// 调整容量
private void ensureExplicitCapacity(int minCapacity) {
        // 修改次数自增
        modCount++;

         // 若添加元素所需的容量比当前数组长度小了，则扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

// 真正扩容
private void grow(int minCapacity) {
        // 原容量
        int oldCapacity = elementData.length;
        // 新容量是原容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
       // 新容量还是不够，那么新容量就等于minCapacity
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 新容量溢出了
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 拷贝一个新数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
  
// 容量溢出处理
 private static int hugeCapacity(int minCapacity) {
        // 已经超出int范围了，抛OutOfMemoryError
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        // 没超出返回新容量
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

minCapacity代表添加元素所需要的容量，等于原容量+添加的元素个数

Q&A

Q：最大数组容量MAX_ARRAY_SIZE为啥是 Integer.MAX_VALUE - 8？
A：数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。

最后一点需要注意的

java.util包下的集合为啥都不支持增强for或者迭代器迭代修改集合？
答案在ArrayList的迭代器代码中找。

private class Itr implements Iterator {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            // 注意
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                // 注意
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    可以看到每次调用迭代器的next方法获取下一个元素的时候，总是会执行checkForComodification，这个方法会对比modCount和expectedModCount是否一致，如果不一致则抛出ConcurrentModificationException。而add、remove、clear等方法都会修改modCount的值。
    调用迭代的remove方法则不会有这个问题，因为每次remove都会更新expectedModCount的值