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不是线程安全的类