Java集合之ArrayList

ArrayList 实现了List接口，它的底层是一个数组，和LinkedList不一样，它占有的是一段连续的空间。ArrayList的元素读取相对LinkedList快很多，因为底下的数组都是按index来的，不像LinkedList需要通过prev或next一个个依次去找。但是相对LinkedList，ArrayList增加元素和减少元素的代价比较大，很多情况下需要新建一个数组再将内容一个个拷贝过去。

构造方法

1.带参构造

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);        }    }

这里提到了initialCapacity，elementData和EMPTY_ELEMENTDATA。
ArrayList初始化的时候，底层会创建一个数组，initialCapacity是这个数组的size。
创建完数组，将其赋值给elementData。
EMPTY_ELEMENTDATA代表了一个空数组，size为0。

2.无参构造

public ArrayList() {        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }

这里的DEFAULTCAPACITY_EMPTY_ELEMENTDATA代表了一个空数组，size为0。
也就是说将一个空数组赋值给elementData。

常用方法

1. add(E e)

public boolean add(E e) {        //保证底层的数组有多余的空位可以放这个e元素。        ensureCapacityInternal(size + 1);  // Increments modCount!!        //ArrayList的size加一，并且将e放到数组(有元素项)的最后        elementData[size++] = e;        return true;    }private void ensureCapacityInternal(int minCapacity) {        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            //DEFAULT_CAPACITY=10,minCapacity是加完元素之后的大小            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }        ensureExplicitCapacity(minCapacity);    }private void ensureExplicitCapacity(int minCapacity) {        modCount++;        // overflow-conscious code        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);    }

总结：往ArrayList中加元素的时候，总是先以实际的元素量为基准，来确定是否要换成一个更长的数组。
底层数组长度小于10的，默认换成一个10长度的数组
底层数组长度>实际元素数量>10的，直接插入元素
10<底层数组长度<实际元素数量的，换成一个底层数组*1.5 长度的数组，插入元素

2. size()

public int size() {        return size;    }

总结：返回元素数量，刚创建完的ArrayList的size都是0

3. get(int index)

public E get(int index) {        rangeCheck(index);        return elementData(index);    }

总结：先确认index是否合法，即和size比较一下，然后返回底层数组对应的元素

4. remove(int index)

public E remove(int index) {        rangeCheck(index);        modCount++;        E oldValue = elementData(index);        int numMoved = size - index - 1;        if (numMoved > 0)            System.arraycopy(elementData, index+1, elementData, index,                             numMoved);        elementData[--size] = null; // clear to let GC do its work        return oldValue;    }

总结：先确认index是否合法，即和size比较一下，然后将要被remove的元素之后的那些元素拷贝到那个元素的位子以及其后。再将最后面那个多余的元素置空

4. remove(Object o)

public boolean remove(Object o) {        if (o == null) {            for (int index = 0; index < size; index++)                if (elementData[index] == null) {                    fastRemove(index);                    return true;                }        } else {            for (int index = 0; index < size; index++)                if (o.equals(elementData[index])) {                    fastRemove(index);                    return true;                }        }        return false;    }private void fastRemove(int index) {        modCount++;        int numMoved = size - index - 1;        if (numMoved > 0)            System.arraycopy(elementData, index+1, elementData, index,                             numMoved);        elementData[--size] = null; // clear to let GC do its work    }

总结：依次和ArrayList里的元素进行对比，碰到匹配的，然后将要被remove的元素之后的那些元素拷贝到那个元素的位子以及其后。再将最后面那个多余的元素置空。其实这里的fastRemove比起上面的按照index remove少了一步确认index合法性的过程。

注意：LinkedList不是线程安全的类