Java集合源码分析之ArrayList

前言

ArrayList可以说是我们日常开发中特别经常使用到的集合类了，本文将结合JDK1.8源码从线程安全、数据结构、初始化、扩容、增删改查、特性总结等几个部分去分析ArrayList

线程安全

ArrayList是非线程安全的，不支持并发。我们可以从它的数据迭代器ArrayList$Itr中可以得知，当产生线程安全问题时会抛出抛出ConcurrentModificationException异常。内部是通过一个modCount变量记录集合的变化，在扩容与删除及清空等操作都会将modCount自增，以此来标记集合的改变。

如何实现线程安全

1.通过Colletions.synchronizedCollection获取线程安全的集合对象
2.使用并发库下的CopyOnWriteArrayList（读写分离）

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; // 记录初始modCount

        ......

        @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];
        }

        // 在next与remove前都会检查modCount是否改变
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

数据结构

ArrayList采用数组对数据进行管理，大量采用了数组的copy实现增删。因此对于性能上，ArrayList的增删操作较慢，由于数组是连续的内存空间所以改查较快。

初始化

提供了三个重载构造方法，除了默认的无参构造器外还可以指定初始容量以及初始集合内容。需要注意的是在参数无效时（初始容量指定为0或者集合）都跟默认构造器结果一致，将数据指定为默认的空数组，这样的好处是当该list没有真正去使用时不会浪费内存。

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

    public ArrayList() { // 空构造器直接指定数组为空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    public ArrayList(Collection c) {
        elementData = c.toArray(); // 将集合转为数组
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                // 通过Arrays.copyOf方法进行数组复制，得到新数组。底层是通过System.arraycopy进行的，本质是native
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

扩容

ArrayList的扩容其实就是数组的扩容，而实际上数组是没办法扩容的。所以只能够构造新的数组，然后把原数组的数据进行copy到新数组，以此完成扩容操作。默认为原数组的1.5倍

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++; // 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);
        // 如果1.5倍仍然无法满足，则直接扩容为minCapacity
        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);
    }

增操作

增操作首先进行一些基本条件判断，包括是否扩容、指定的index是否越界。在add(int index, E element)方法中也需要进行扩容，因为可能添加新元素后，新size可能刚好等于当前容量。赋值就很简单了，因为是数组结构，直接通过index指定即可，唯一需要注意的是在赋值之前的数组copy

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

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 将数组进行拷贝，留出index位置
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 对index位置进行赋值
        elementData[index] = element;
        size++;
    }

删操作

删除操作有两种形式，指定对象或者指定位置，注意此处也修改modCount变量了。指定位置：首先越界检查，接着通过数组copy将指定index的位置覆盖，最后指定--size为null。指定对象：分两种情况，一种是对象为null，一种是对象非空。

    public E remove(int index) {
        rangeCheck(index); // 越界检查

        modCount++;
        E oldValue = elementData(index); // 删除的目标对象

        int numMoved = size - index - 1; // 数据需要移动的数量
        if (numMoved > 0) // copy
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 最后一个赋值null
        elementData[--size] = null; // clear to let GC do its work
        // 返回目标对象
        return oldValue;
    }

    public boolean remove(Object o) {
        // 指定对象的remove操作是通过循环比较
        if (o == null) { // null
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true; // 返回的boolean表示是否移除成功
                }
        } else { // 非空
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

改操作

很简单，越界检查 - > 取原值 - > 修改 - > 返回原值

    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

查操作

很简单，越界检查 - > 返回对象

    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

特性总结

1.数据结构为数据，增删慢、改查快
2.非线程安全，通过modCount控制
3.ArrayList与Vector的区别：Vector是线程安全的，通过synchronized关键字；Vector扩容是容量翻倍，而ArrayList是原容量1.5倍