深入学习Java之ArrayList

前言

对于Java的容器类，虽然之前一直有在使用，不过使用归使用，很多的原理本质上还是不懂，比如说什么时候进行扩容等，乘着最近有空，每天抽出点时间来重新学习下容器类，主要包括了(Collection、Map)，其中Collection主要包括List、Set、Queue等，本小节主要来学习List中的ArrayList

ArrayList的继承结构

首先从宏观上来了解ArrayList的结构，然后再从源码的角度来学习。

ArrayList的继承结构如下所示

从上图中可以看到，ArrayList继承自AbstractList，并且实现了RandomAccess、Clonable、Serializable接口，而其中的AbstractList又实现了AbstractCollection接口，并且继承了List接口，AbstractCollection实现了Collection接口，List继承了Collection接口，Collection接口又继承了Iterable接口。

接下来我们根据上图，从上到下来逐个类、接口来学习

首先是Iterable接口

从上图中可以看到，Iterable接口中主要提供了iterator方法，用于返回一个Iterator对象，主要用于遍历容器(foreach)

接下来是Collection接口

从上图中可以看到，Collection接口基本上定义了操作容器的基本方法，包括了获取容器大小的size方法，判断容器是否为空的isEmpty方法，判断容器是否包含某个元素的contains方法，将容器的内容装换为数组的toArray方法，添加元素的add方法，移除元素的remove方法等，这些方法都是操作容器的最基本的方法，在对应的实现类中，不同的容器实现类将根据自身的特性，对不同的方法进行相应的实现。

接下来是AbstractCollection接口，AbstractCollection是一个抽象类，主要实现了Collection接口中的部分通用方法，具体如下代码所示

    public boolean contains(Object o) {        // 获得迭代器对象        Iterator<E> it = iterator();        // 判断对象是否是NULL，如果是NUll，则查看容器中是否        // 有对象也是NULL        if (o==null) {            while (it.hasNext())                if (it.next()==null)                    return true;        } else {            // 如果不是NULL，则查看容器中是否包含该方法            while (it.hasNext())                if (o.equals(it.next()))                    return true;        }        return false;    }

    // 原理同上    public boolean remove(Object o) {        Iterator<E> it = iterator();        if (o==null) {            while (it.hasNext()) {                if (it.next()==null) {                    it.remove();                    return true;                }            }        } else {            while (it.hasNext()) {                if (o.equals(it.next())) {                    it.remove();                    return true;                }            }        }        return false;    }

    // 将容器转化为数组    public Object[] toArray() {        // 默认大小为容器中元素的个数        Object[] r = new Object[size()];        Iterator<E> it = iterator();        for (int i = 0; i < r.length; i++) {            // 当发现容器中的元素个数没有那么多时，将数组进行缩减            if (! it.hasNext()) // fewer elements than expected                return Arrays.copyOf(r, i);            r[i] = it.next();        }        // 当发现容器中个数多余size时，进行扩容，并将剩余元素添加到数组中        return it.hasNext() ? finishToArray(r, it) : r;    }    // 将容器中剩余的元素加入到数组中    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {        int i = r.length;        while (it.hasNext()) {            int cap = r.length;            if (i == cap) {                // 当发现数组容量不足时，进行扩容，扩容后大小为原来的大小+原来大小的1/2 + 1                int newCap = cap + (cap >> 1) + 1;                // 对扩容后的大小进行判断，防止容量过大                // 其中的 MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;                // 也就是如果扩容后的大小大于Integer.MAX_VALUE - 8，则进行                // 容量判断，防止其整数溢出                if (newCap - MAX_ARRAY_SIZE > 0)                    newCap = hugeCapacity(cap + 1);                r = Arrays.copyOf(r, newCap);            }            r[i++] = (T)it.next();        }        // 如果数组容量由空余，则进行缩减至数组容量大小        return (i == r.length) ? r : Arrays.copyOf(r, i);    }    // 限制数组容量    private static int hugeCapacity(int minCapacity) {        // 如果新容量太大，造成整数溢出，则抛出异常        if (minCapacity < 0) // overflow            throw new OutOfMemoryError                ("Required array size too large");        // 如果大于允许的最大容量，则将其限制在Integer.MAX_VALUE        // 否则则将其限制在MAX_ARRAY_SIZE        return (minCapacity > MAX_ARRAY_SIZE) ?            Integer.MAX_VALUE :            MAX_ARRAY_SIZE;    }

当然，AbstractCollection中还有其他一些方法，不过，由于在具体的实现类中，可能对应的实现不同，所以这里就不进行其源码的研究，等到具体的实现类中再进行研究

接下来是List接口

由于List接口继承自Collection接口，所以Collection中有的方法List也自然有，不过，除此之外，List还增加了几个新的方法，主要用于针对List的操作

从上图中可以看到，主要是获取指定位置的get方法，将某个位置的元素设置为新的值的set方法，获取某个元素在List中的索引的indexOf、LastIndexOf方法，以及List增加的用于获取新的迭代器的ListIterator方法

接下来是AbstractList，正如AbstractCollection之于Collection，AbstractList是List的实现，主要实现了几个常用的方法，这里同样不进行展开

从ArrayList的结构图中可以看到，ArrayList除了AbstractList和实现了List接口之外，还实现了RandomAccess、Cloneable、Serializable接口，其中RandomAccess、Cloneable和Serializable接口均是标记接口，RandomAccess用于标记ArrayList支持随机访问，Cloneable接口用于标记ArrayList支持克隆，Serializable接口用于标记ArrayList支持序列化

ArrayList的源码剖析

上面从宏观上了解了ArrayList的继承结构，总体把握了ArrayList的方法之后，接下来我们来详细地学习ArrayList的源码

ArrayList的组成

transient Object[] elementData;

可以看到，ArrayList的底层实现其实就是一个Object数组，这也是为什么ArrayList称之为ArrayList的原因了

接下来来学习ArrayList的构造方法

    // 带初始容量的初始化方法    public ArrayList(int initialCapacity) {        // 如果初始容量大于0，则使用该容量进行创建数组        if (initialCapacity > 0) {            this.elementData = new Object[initialCapacity];        // 如果容量是0，则使用默认的的空数组对象，其中的EMPTY_ELEMENTDATA定义如下        // private static final Object[] EMPTY_ELEMENTDATA = {};         } else if (initialCapacity == 0) {            this.elementData = EMPTY_ELEMENTDATA;        // 如果容量小于0，则抛出异常        } else {            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);        }    }    // 无参构造方法，也是默认的构造方法    public ArrayList() {        // 默认也是初始化为空数组        // private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }    // 带一个容器对象的构造方法，主要用于将容器中的所有对象来初始化ArrayList对象     public ArrayList(Collection<? extends E> c) {        // 将Collection转化为数组对象        elementData = c.toArray();        // 如果传进来的Collection中有元素，则将元素添加到数组中        if ((size = elementData.length) != 0) {            // 如果转化后的数组不是Object类型，则初始化为实际类型            if (elementData.getClass() != Object[].class)                elementData = Arrays.copyOf(elementData, size, Object[].class);        // 否则将其初始化为空容量        } else {            this.elementData = EMPTY_ELEMENTDATA;        }    }

获取某个元素

    public E get(int index) {        // 对index的范围进行检查        rangeCheck(index);        return elementData(index);    }    // 对index的范围进行检查，由于对数组进行访问时，负数索引会抛出异常    // 所以这里不需要进行额外检查，但是由于此时数组的容量并不代表所有的    // 位置都是有效元素，所以需要进行检查    private void rangeCheck(int index) {        if (index >= size)            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));    }

将指定位置的元素替换为指定元素

    public E set(int index, E element) {        rangeCheck(index);        // 替换旧值并且返回旧值        E oldValue = elementData(index);        elementData[index] = element;        return oldValue;    }

添加某个元素

    // 默认添加在最后面    public boolean add(E e) {        // 进行容量检测        ensureCapacityInternal(size + 1);         elementData[size++] = e;        return true;    }    // 容量检测    private void ensureCapacityInternal(int minCapacity) {        // 如果是此时的数组的默认的空数组，则将其容量初始化为        // max(默认容量(10), 此时所需要的最小容量)        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }        // 判断此时容量是否足够        ensureExplicitCapacity(minCapacity);    }    private void ensureExplicitCapacity(int minCapacity) {        // 记录对ArrayList结构进行操作        modCount++;        // 如果所需要的容量大于数组此时的长度，则增长数组        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }    // 动态增长，注意这里比较耗费资源    private void grow(int minCapacity) {        int oldCapacity = elementData.length;        // 大小为旧容量大小+ 1/2 旧容量大小        int newCapacity = oldCapacity + (oldCapacity >> 1);        // 如果新容量大小小于所需要的大小，则将大小设置为实际所需要的大小        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        // 如果新容量大小大于允许的最大值，则进行容量检测，看是否移出        if (newCapacity - MAX_ARRAY_SIZE > 0)            newCapacity = hugeCapacity(minCapacity);        // 重新创建数组并且将大小调整为新容量        elementData = Arrays.copyOf(elementData, newCapacity);    }    // 检查容量大小是否溢出    private static int hugeCapacity(int minCapacity) {        if (minCapacity < 0) // overflow            throw new OutOfMemoryError();        return (minCapacity > MAX_ARRAY_SIZE) ?            Integer.MAX_VALUE :            MAX_ARRAY_SIZE;    }

在指定位置插入元素

    public void add(int index, E element) {        rangeCheckForAdd(index);        // 同上，进行容量检测并在需要时进行动态增长        ensureCapacityInternal(size + 1);        // 将要插入的位置的元素后面所有元素后移        // 这里可以看出，ArrayList在中间插入元素是比较消耗资源的        System.arraycopy(elementData, index, elementData, index + 1,                         size - index);        elementData[index] = element;        size++;    }

添加一个容器中的所有元素

    // 基本原理同上，这里不进行过多的解析    public boolean addAll(Collection<? extends E> c) {        Object[] a = c.toArray();        int numNew = a.length;        ensureCapacityInternal(size + numNew);  // Increments modCount        System.arraycopy(a, 0, elementData, size, numNew);        size += numNew;        return numNew != 0;    }

移除指定位置元素

    public E remove(int index) {        rangeCheck(index);        modCount++;        E oldValue = elementData(index);        int numMoved = size - index - 1;        // 如果要移出的元素不是最后一个元素，则进行紧凑        // 从这里也可以看到，ArrayList在中间移除元素是比较消耗资源的        if (numMoved > 0)            System.arraycopy(elementData, index+1, elementData, index,                             numMoved);        elementData[--size] = null; // clear to let GC do its work        return oldValue;    }

在指定位置添加所有的元素

    // 基本原理同上，不做过多解析    public boolean addAll(int index, Collection<? extends E> c) {        rangeCheckForAdd(index);        Object[] a = c.toArray();        int numNew = a.length;        ensureCapacityInternal(size + numNew);  // Increments modCount        int numMoved = size - index;        if (numMoved > 0)            System.arraycopy(elementData, index, elementData, index + numNew,                             numMoved);        System.arraycopy(a, 0, elementData, index, numNew);        size += numNew;        return numNew != 0;    }

移除指定值的元素

    // 移除第一个匹配的值    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    }

移除所有元素

    public void clear() {        modCount++;        // 这里需要注意，由于数组中的元素是通过引用关系跟        // 具体的对象关联的，所有如果此时只是简单的移动索引        // 那么这些元素所占用的内存依旧不会被GC，因为依旧保持        // 跟数组的管理，GC回收是不会对这种对象进行回收的        // 这里写得非常棒，非常值得学习        for (int i = 0; i < size; i++)            elementData[i] = null;        size = 0;    }

查找某个元素的索引以及查找从后往前找某个元素的索引基本同AbstractCollection，这里就不进行展开了

克隆数组

    public Object clone() {        try {            ArrayList<?> v = (ArrayList<?>) super.clone();            v.elementData = Arrays.copyOf(elementData, size);            v.modCount = 0;            return v;        } catch (CloneNotSupportedException e) {            // this shouldn't happen, since we are Cloneable            throw new InternalError(e);        }    }

手动触发容量检测

    public void ensureCapacity(int minCapacity) {        // 如果是默认的空数组，则容量为0，否则容量为10        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;        // 对最小容量与需要的容量进行判断，并根据需要进行容量扩展        if (minCapacity > minExpand) {            ensureExplicitCapacity(minCapacity);        }    }

手动将ArrayList中数组的大小进行确定，限制为实际的大小

    public void trimToSize() {        modCount++;        if (size < elementData.length) {            elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);        }    }

对与ArrayList中的Iterator以及ListIterator的源码，目前还没看懂，所以暂时无法进行研究，等以后研究懂了再进行补充

总结

本小节主要从宏观上学习了ArrayList的结构，以及从ArrayList的源码中研究了ArrayList的底层实现，以及ArrayList的扩容，紧凑原理(数组的拷贝，移动)，从本质上明白了为何ArrayList在中间进行插入，删除会带来严重性能的原因(数组元素的移动)，加深了对ArrayList的认识。