初步理解ArrayList

Java给我们提供了一套非常好用的容器框架，大体包含了List、Set、Map。这三大类容器，每类下面又有多种实现，今天我们就来初步的探究一下List下的ArrayList的实现。

稍微了解过数据结构的同学们都知道，List的底层其实是使用数组来实现的，而大家都知道数组是固定长度的，List是变长的，这怎么实现的。下面我们就一起来探究一下这部分的内容。
首先我们先来看看ArrayList的源码，打开eclipse，找到JDK中提供的ArrayList，我们轻易的可以发现这行代码：

private transient Object[] elementData;

这句代码是干嘛的？这就是我们要研究的对象，底层的Object数组。

除此之外，还有三个构造方法：

 public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        if (elementData.getClass() != Object[].class)
        this.elementData = new Object[initialCapacity];
    }

    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

从这三个构造方法中，我们得知：

1. 第一个构造方法，我们传递了一个int类型的初始化值，这个值告诉了 elementData 的初始化值是多少。
2. 第二个构造方法，也就是我们平常用的最多的构造方法了，那EMPYT_ELEMENTDATA的长度是多大呢？我们待会儿再说。
3. 第三个构造方法，接收一个集合对象，并且在方法体中先行利用这个集合对象将 elemenetData对象给初始化了。

回到第二个构造方法中来，我们看看这个EMPYT_ELEMENTDATA到底是何方神兽。。。

 private static final Object[] EMPTY_ELEMENTDATA = {};

其实我们从变量名中也看出来了，它是空的。所以，当我们使用

List<T> list = new ArrayList<T>();

这句代码来初始化的时候，它其实给了我们一个长度为0的数组对象。

OK！容器实例创建好了，下面我们来添加数据：

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

等等，我们的数组长度为0，怎么添加数据？？？黑人问号脸。

秘密就在ensureCapacityInternal方法中，我们跟踪代码进去一探究竟~

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        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);
    }

在ensureCapacityInternal() 方法中确定了最小的初始化大小，紧接着又调用了ensureExplicitCapacity()方法，最后，重点来了：调用了grow(int) 方法，如果我们使用的是无参的构造方法，那么最终的初始化数组的地方就在grow(int)方法中

并且，如果我们在使用add方法添加数据时，占满了数组时也是通过此方法进行扩容，还记得我们是从add方法跟踪进来的吗？

扩容是怎么一个扩容方式？

int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);

变量oldCapacity保存的是原数组的长度大小，newCapacity保存的是新的长度，新长度怎么确定？ 新长度=旧长度+旧长度的一半（不严谨）。

举个栗子：

通过代码的分析，我们可以知道，第一次初始化的长度为10， 10 >> 1 = 5 所以，当我们第一次把Object[] 数组填满时，它扩容到了15个元素。

再使用Arrays.copyOf();方法拷贝原数组内容到扩容后的新数组中。整个过程大致如此。

第一次正儿八经看一个类的源码，欢迎大神拍砖，只要拍不死，那就随便拍。