Java集合类学习--ArrayList

概述

ArrayList 是 List 接口的一个实现类，也是 Java 中最常用的容器实现类之一，可以把它理解为「可变数组」。

我们知道，Java 中的数组初始化时需要指定长度，而且指定后不能改变。ArrayList 内部也是一个数组，它对数组的功能做了增强：主要是在容器内元素增加时可以动态扩容，这也是 ArrayList 的核心所在。

ArrayList 的主要方法与 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);
        }
    }

    //该构造器涉及两个变量：
	//elementData 和 DEFAULTCAPACITY_EMPTY_ELEMENTDATA。
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    //指定初始化集合的构造器
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

无参构造器：
1、 elementData 是一个 Object 类型的数组，该数组也是 ArrayList 作为容器用于存储数据的地方。
2、DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是一个 Object 类型的空数组。因此，该无参构造器的作用就是将 elementData 初始化为一个 Object 类型的空数组。

初始化容量构造器：
1、根据传入的初始容量（initialCapacity）初始化用于存储元素的数组 elementData 变量。当初始容量为 0 时，elementData 被初始化为 EMPTY_ELEMENTDATA。
2、EMPTY_ELEMENTDATA与 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 都是一个空的 Object 数组，二者名字不同是为了区分 ArrayList 初始化时是否指定了容量，后期进行扩容的时候有所不同。
初始化集合构造器：
该构造器传入一个集合 Collection，即使用 Collection 中的元素初始化 ArrayList 对象。

add(E e)方法

// 将指定的元素添加到 List 末尾
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 检查是否需要扩容
    elementData[size++] = e;
    return true;
}

可以看到，在 add() 方法执行时，会首先执行 ensureCapacityInternal() 方法：

	//若使用无参构造器，在调用该方法的时候会使用DEFAULT_CAPACITY，也就是10
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

再去调用ensureExplicitCapacity（），里面会判断是否需要执行 grow() 方法：

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

grow() 方法：

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

1、int newCapacity = oldCapacity + (oldCapacity >> 1);代表新容量是老容量的1.5倍。
2、if (newCapacity - minCapacity < 0)newCapacity = minCapacity;以实际容量为主
3、if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);如果已经超过最大容量，以最大容量为主
4、elementData = Arrays.copyOf(elementData, newCapacity);创建新容量的数组并把老数组拷贝到新数组。

注意：
ArrayList 是线程不安全的，主要体现有二：
多个线程往 ArrayList 添加数据时（扩容时），可能会产生数组越界异常（ArrayIndexOutOfBoundsException）；
多个线程遍历同一个 ArrayList，有线程对其进行修改时，可能会抛出 ConcurrentModificationException。
i++ 操作是非原子性的。

add(int index, E element)方法

//添加元素至指定位置
 public void add(int index, E element) {
		 // 检查是否越界
        rangeCheckForAdd(index);
		//是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将index及其之后的元素往后挪一位,空出index位置给新元素添加
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        //长度加1
        size++;
    }

其他add方法类似操作

get(int index)方法

    public E get(int index) {
        rangeCheck(index);
        //返回的是索引位置的元素
        return elementData(index);
    }

        private void rangeCheck(int index) {
            if (index < 0 || index >= this.size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }

remove(int index)方法

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

    modCount++;
    // 获取index位置的元素
    E oldValue = elementData(index);
    
    // 如果index不是最后一位，则将index之后的元素往前挪一位
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    
    // 将最后一个元素删除，帮助GC
    elementData[--size] = null; // clear to let GC do its work

    // 返回旧值
    return oldValue;
}

（1）检查索引是否越界；
（2）获取指定索引位置的元素；
（3）如果删除的不是最后一位，则其它元素往前移一位；
（4）将最后一位置为null，方便GC回收；
（5）返回删除的元素。
可以看到，ArrayList删除元素的时候并没有缩容。
其他remove方法类似。

iterator()方法

    public Iterator<E> iterator() {
        return new Itr();
    }

会创建一个内部类 Itr，如下：

    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

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

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

ArrayList 的 add()、remove() 等结构性修改的操作都会使 modCount++。
因此有：
若线程 T1 只对 ArrayList 进行遍历；
而线程 T2 对同一个 ArrayList 进行了移除元素操作，则会修改 modCount 的值，导致线程 T1 中 modCount != expectedModCount，从而触发 ConcurrentModificationException。

小结

ArrayList 可以理解为「可以自动扩容的数组」，默认初始化容量为 10，默认每次扩容为原容量的 1.5 倍；
扩容时会创建一个新的数组，并将之前的元素拷贝到新数组中（因此，若要将数量已知的元素放入 ArrayList，在初始化时指定长度可以避免多次扩容）；
ArrayList 线程不安全，不适合在多线程场景下使用。
扩展：
（1）ArrayList内部使用数组存储元素，当数组长度不够时进行扩容，每次加一半的空间，ArrayList不会进行缩容；
（2）ArrayList支持随机访问，通过索引访问元素极快，时间复杂度为O(1)；
（3）ArrayList添加元素到尾部极快，平均时间复杂度为O(1)；
（4）ArrayList添加元素到中间比较慢，因为要搬移元素，平均时间复杂度为O(n)；
（5）ArrayList从尾部删除元素极快，时间复杂度为O(1)；
（6）ArrayList从中间删除元素比较慢，因为要搬移元素，平均时间复杂度为O(n)；
（7）ArrayList支持求并集，调用addAll(Collection<? extends E> c)方法即可；
（8）ArrayList支持求交集，调用retainAll(Collection<? extends E> c)方法即可；
（7）ArrayList支持求单向差集，调用removeAll(Collection<? extends E> c)方法即可；