Java_ArrayList的工作原理

Resizable-array implementation of the List interface.  Implements
all optional list operations, and permits all elements, including
null.  In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list.  (This class is roughly equivalent to Vector, except that it is unsynchronized.)

ArrayList实现了List接口，能够允许添加null,其本质是一个可以扩容的数组，与Vector不同仅仅在于它不是线程安全的。

看下面一个简单的例子：
public class TestArrayList {
    public static void main(String[] args) {
           List<String> list=new ArrayList<String>();
           list.add("1");
           list.add("2");
           list.add("3");
           list.add("4");
           list.add("5");
           list.add("6");
           list.add("7");
           list.add("8");
           list.add("9");
           list.add("10");
           list.add("11");
           list.add("12");
           list.remove("bbb");       
     }
}

当只添加三个元素的时候：

当添加超过10个元素的时候:

可以看到这里数组扩容到了10+10*1/2=15;

---

ArrayList部分源码如下：（jdk1.8）

创建的时候：

 //new ArrayList的时候，如果传入的参数，即初始化容量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);
        }
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        //创建一个空的list
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }  

添加元素的时候：

 public boolean add(E e) {
        //检查在添加一个元素的时候是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }


 private void ensureCapacityInternal(int minCapacity) {
        //数组为空的时候
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //数组容量取DEFAULT_CAPACITY与minCapacity最大值
            //如果创建list的时候，没有指定容量大小，这里取DEFAULT_CAPACITY的大小10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
   }

    private void ensureExplicitCapacity(int minCapacity) {
        //操作的次数+1
        modCount++;
        // overflow-conscious code
        //添加一个元素后比数组的长度大，则进行扩容处理
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //扩容操作
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //新数组的长度为原数组的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)
            //扩容后的数组比需要的数组容量还是小，这里主要指在创建ArrayList的时候指定的数组容量的大小，则直接把数组的容量扩充到所需大小
            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);
    }

---

get操作

 public E get(int index) {
        //检查是否越界
        rangeCheck(index);
        return elementData(index);
    }

---

总结：
Arraylist在没有自己初始化容量大小的时候，会创建一个默认大小为10的数组，当数组元素的添加大于10的时候，会进行扩容处理，扩容后的大小为原数组的1.5倍，然后把元素复制到新的数组中，这也就是可变数组的机制。一般在事先知道数组大小为多少的时候，尽量自己手动的指定数组的大小，因为数组的不断扩容是会降低性能的。