Java基础干货ArrayList源码剖析

Posted 2021-06-04 在路上的德尔菲

本文所有代码来自JDK1.8

ArrayList简介

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList继承了AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable接口

java.lang.Object
   java.util.AbstractCollection<E>
      java.util.AbstractList<E>
         java.util.ArrayList<E>

List是动态数组,并允许操作所有元素，包括null。

每个ArrayList实例都有一个容量大小，此容量是列表数组中能够存储元素的个数，它始终是大于等于元素个数的。当ArrayList中添加元素时，其容量会自动增加。在通过ensureCapacity方法添加大量元素之前，预判需要的容量，因此可以手动设置ArrayList实例的容量，这样会减少重新分配的次数。

ArrayList实现是不同步。如果多个线程同时访问ArrayList实例，并且至少有一个线程在结构上修改了列表，则必须进行同步,结构修改是指添加或删除一个或多个元素的操作，或显式调整后备数组的大小;仅设置元素的值不是结构修改。

常用函数

面试常问问题

1、如何扩容的？
2、线程安全吗？如何确保线程安全
3、如何初始化？
4、查找、添加、删除元素时间复杂度？
5、ArrayList与LinkedList的比较

源码分析

    /**
     * 默认初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于没有实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于默认大小空实例的共享空数组实例
     *  区别于EMPTY_ELEMENTDATA， 当第一个元素添加进来可知该如何膨胀
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * ArrayList的底层数据结构
     * 任何空ArrayList元素类型为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * 当第一个元素添加进来将扩展为DEFAULT_CAPACITY 
     * 
     */
    transient Object[] elementData; //非私有，以简化嵌套类访问

注意：transient关键字是指在采用Java默认的序列化机制的时候，被该关键字修饰的属性不会被序列化，说明此属性不采用默认序列化方法，因为自己实现了序列化和反序列化(writeObject和readObject)。

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

1、序列化中记录列表中的个数，且按顺序序列化
2、序列化过程中若出现modCount != expectedModCount，也会抛出ConcurrentModificationException

     /**
     * 包含的元素个数，与容量做区别
     */
    private int size;
    /**
     * 最大数组大小为Integer.MAX_VALUE - 8
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

初始化函数

    /**
     * 构建一个指定容量的空列表
     */
    public  ArrayList(int initialCapacity) {
        //创建输入大小的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        //初始容量为0，初始化一个空数组
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        //当输入的初始化容量不符合要求，抛出IllegalArgumentException
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     * 构建一个容量为10的空列表
     */
    public  ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构建一个包含指定集合的所有元素的列表，元素顺序按照集合迭代器返回的顺序
     */
    public  ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // 将原来集合中元素向上转换为Object类型
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 当集合元素为0，初始化一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    /**
     * 把ArrayList的容量减小到元素数目大小，可最小化存储
     */
    public void trimToSize() {
        modCount++;//算结构性改变
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

查找元素

假设一群人在排队，每个人按顺序都代表一个号，第一个人正在办理业务代表0号，后面的人依次排开1,2,3,4号，当工作人员喊到3号的时候，这个人知道是自己就可以站出来，就相当于get(index)操作。

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

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

首先判断要查找的下标是否大于等于数组大小（从0开始存数据），若没有返回该位置元素，否则抛出下标越界异常

    //通过indexOf(o)来判断是否存在对应元素
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

1、首先判断输入元素是否为null，避免空指针异常（ArrayList可以存null元素）
2、indexOf方法从头到尾遍历，lastIndexOf方法从尾到头遍历
3、找到则返回相应位置下标，为大于等于0的整数，没有找到相应元素则返回-1

下面用图举例：

添加元素

假设在一群人在排队中，突然来了一个人，正常的话是排到队尾的，相当于add(E e);但是这个人可能有急事就会选择插队，那么他找个位置插进去，那么他插进去位置后面的人都需要往后走一步才会产生空间，这就相当于add(int index, E element)

    //在列表末尾添加元素
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

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

1、首先调用ensureCapacityInternal(size + 1)，如果elementData为空，则minCapacity设置为10和size+1中最大值
2、发生结构性改变，modCount会增加1
3、如果此时的容量还小于元素的个数，说明数组已经放满，则需要进行扩容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、获取当前数组长度oldCapacity
2、新的长度为oldCapacity + (oldCapacity >> 1)，即将oldCapacity右移一位然后加1，新容量是旧容量的1.5倍+1
3、如果newCapacity <minCapacity,则新容量设置为minCapacity
4、如果新容量比允许的最大数组容量都要大，则新容量设置为虚拟机允许的最大值
5、将elementData放入新容量数组中

    //在列表中任意位置添加元素
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  

        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

1、不仅检查输入的索引是否大于数组大小，还判断是否小于0
2、发生结构性改变，其中modCount增加1
3、向后移动一部分元素，为要添加的元素腾出空间
4、在所在下标添加元素
5、list中元素个数加1

下面用图举例展示：

    //指定集合所有元素添加到list集合中，添加了返回true，否则返回false
    public boolean addAll(Collection<? extends E> c) {// E代表父类 ，？代表 子类 
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        //若加入的是空集合则返回false
        return numNew != 0;
    }System.arraycopy(src, srcPos, dest, destpoS,length);

其中各个参数意义如下：
Object  src  ： 从哪复制 -- 源数组.
int  srcPos  ： 源数组从哪个下标开始复制.
Object  dest ： 复制到哪 -- 目的数组.
int  destPos  ：粘贴到开始下标的位置.
int  length   ：将要被复制的元素个数.

删除元素

    //删除指定位置上的元素
    public E remove(int index) {
        rangeCheck(index);//1

        modCount++;//2
        E oldValue = elementData(index);//3

        int numMoved = size - index - 1;//4
        if (numMoved > 0)//5
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; //6

        return oldValue;//7
    }

1、判断输入的索引是否小于数组个数，否则抛异常结束
2、发生结构性改变，modCount需要增加1
3、旧值需要返回，记录旧值
4、计算移动的元素个数，下图举例5-2-1=2个
5、数组进行左移操作，即删除了要删除的元素
6、最后位置设置为null,下次gc就会回收这些元素所占的内存空间
7、返回旧值

下面用图举例：

    //删除指定的元素
    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; 
    }

1、首先判断是否是null，避免空指针异常，然后从头到尾遍历找对应元素，找到删除返回true，否则返回false。
2、fastRemove(int index)与上面的remove(int index)类似，但少了边界检测，因为说明已经在边界内找到了相应元素。
3、关键modCount++;,下面细节扩展分析中会用到

将list对象转换为数组对象

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

toArray()作为数组对象和集合对象转化的桥梁，将返回包含list中所有元素的一个新分配的数组。

使用建议

与LinkedList相比

时间复杂度分析

1、ArrayList基于索引结构，在中间插入或删除一个元素会导致列表中一部分元素移动，适合查找操作，不适合中间插入、删除操作；LinkedList基于链表结构，在中间插入或删除元素的开销是固定的，因此适合频繁插入、删除操作。

2、在ArrayList的添加元素，当达到阈值会导致数组进行重新分配的容量。

3、ArrayList的空间浪费主要体现在list列表的结尾预留一定的容量空间；而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间，包括指向指针

与Array相比

1、ArrayList内部封装了一个Object类型的数组，本质与数组没有差别，一些方法内部都是调用array方法实现的。

2、可以将ArrayList看成一种会自动扩增容量的Array，而Array一旦分配容量则不能动态改变。

3、Array既可以存储基本类型元素，也可以存储对象类型元素；而ArrayList只能存储对象类型元素

细节扩展

fail-fast为快速失败机制，为Java集合的一种错误检测机制

此类的iterator和listIterator方法返回的迭代器是fail-fast的：如果在创建迭代器之后的任何时候对列表进行结构修改，比如通过迭代器自己的remove或add方法，迭代器将抛出ConcurrentModificationException。因此，在并发修改的情况下，迭代器会快速停止操作，而不是在未来的未确定时间发生非确定性行为的风险，而且即使不是在多线程环境，如果单线程违反了规则，同样也会抛出异常。其中阿里巴巴开发手册中规定如下：

在foreach循环中进行元素删除，为什么会引起fail-fast机制呢？因为foreach循环中集合遍历底层是通过iterator进行的。

通过iterator直接运行，当然抛出同样的异常结果。

通过堆栈信息可以得到异常发生在调用链第14行，String next = iterator.next();中调用了iterator().checkForComodification()方法，而异常就是这个方法中抛出的,看下抛出异常的原因。

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

说明发生了modCount != expectedModCount,才抛出的异常。接下来我们来分析modCount和expectedModCount这两个变量
插入图expectedMod

• modCount是AbstractList中一个成员变量，被ArrayList继承，表示该集合中实际被修改的次数，用于在遍历集合iterator时，检测是否发生了add、remove等结构性改变的操作。

• expectedModCount 是ArrayList中内部类Itr中的成员变量，表示这个迭代器期望该集合被修改的次数,只有通过迭代器对集合进行操作，该值才会改变。

• Itr是一个Iterator的实现，ArrayList.iterator方法获得的迭代器就是Itr的实例。

    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
}

他们之间的关系如下：

class ArrayList{
    private int modCount;
    public void add();
    public void remove();
    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
    }
    public Iterator<E> iterator() {
        return new Itr();
    }
}

是什么导致modCount != expectedModCount，通过之前分析源码可知fastRemove(int index)中modCount加1，但此时expectedModCount并没有增加1，才导致两个数不相等。

简单来说集合遍历是通过iterator进行的，但是元素的add/remove却是使用类中自己的方法吗，因此混淆在了一起，导致iterator在遍历的时候，当一个元素通过自己方法添加或删除时，就会抛出一个异常。

知道了以后我们可以选择正确的方法在遍历的时候删除一些元素
1、使用普通for循环，此时没有使用iterator

2、迭代器iterator的remove()方法

 

参考:

Java Standard Ed. 8 https://docs.oracle.com/javase/8/docs/api
Holis https://mp.weixin.qq.com/s/e9ITxUmsMFhfjeHhOgTtfA