[Java]ArrayList源码解析

ArrayList源码解析

1. 核心源码解读

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

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

    /**
     * 空数组（空实例）
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于默认大小空实例的共享空数组实例
     * 把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 保存ArrayList数据的数组
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList 所包含的元素个数
     */
    private int size;

    
    /************************************* ArrayList的三种初始化方法 *************************************/
    
    /**
     * 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            // 如果传入的参数大于0，创建 initialCapacity 大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            // 如果传入的参数等于0，创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            // 如果传进的容量为负值则抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }

    /**
     * 默认无参构造函数
     * DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0
     * 初始化时是空数组，当添加第一个元素的时候 elementData 数组容量才变成10（DEFAULTCAPACITY_EMPTY_ELEMENTDATA依旧是空数组，只是与EMPTY_ELEMENTDATA做区分）
     * 具体获得初始容量 10 函数在 ensureCapacityInternal
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
     */
    public ArrayList(Collection<? extends E> c) {
        // 将指定集合转换为数组
        elementData = c.toArray();
        // 如果elementData数组的长度不为0
        if ((size = elementData.length) != 0) {
            // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
            if (elementData.getClass() != Object[].class)
                // 将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
                // Arrays.copyOf 的底层是使用了 System.arraycopy 方法进行实现
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 其他情况用空数组代替
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
    
        
    /************************************* end *************************************/

    
    /**
     * 修改这个ArrayList实例的容量是列表的当前大小。
     * 应用程序可以使用此操作来最小化ArrayList实例的存储。
     */
    public void trimToSize() {
        // modCount 是 AbstractList 类中的变量，表示这个List结构被修改的次数
        // 每次对List进行操作modCount数量都会+1
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }
    
    
    
    /************************************* ArrayList扩容机制 *************************************/
    
    // ArrayList的扩容机制提高了性能，如果每次只扩充一个，
    // 那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
    
    /**
     * 手动扩容
     * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
     * 
     * @param minCapacity 所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        // 如果elementData不为空数组，minExpand的值为0，如果elementData为空数组,minExpand的值为10
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;
        // 如果最小容量大于已有的最大容量
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    
    /**
     * 【核心】内部数组自动扩容方法
     * 
     * @param minCapacity 所需的最小容量
     */
    private void ensureCapacityInternal(int minCapacity) {
        // 第一次给ArrayList新增元素的时候，在这里给elementData的容量赋初值为 10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 取【默认的容量】和【传入所需的最小容量】两者之间最大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    /**
     * 判断是否需要进行扩容
     * 所需的最小容量 > 数组的长度，需要进行扩容
     * 所需的最小容量 <= 数组的长度，不需要进行扩容
     * 
     * @param minCapacity 所需的最小容量
     */
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // 如果所需的最小容量大于数组的长度，需要进行扩容
        if (minCapacity - elementData.length > 0)
            // grow为具体的扩容方法，调用此方法代表已经开始扩容
            grow(minCapacity);
    }

    /**
     * ArrayList数组的最大长度
     * Integer.MAX_VALUE - 8 是因为，-8位置是存放数组在内存中头部信息。
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * ArrayList扩容的核心方法
     * 
     * @param minCapacity 所需的最小容量
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧数组容量
        int oldCapacity = elementData.length;
        
        // newCapacity为新容量
        // 将oldCapacity 右移一位，其效果相当于oldCapacity/2，所以这个运算表示新容量的大小扩展到旧容量大小的1.5倍
        // 位运算的速度远远快于整除运算，所以使用移位运算符进行计算
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        
        // 检查新容量是否大于最小需要容量，若还是小于最小需要容量，就需要把最小需要容量当作数组的新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        
        // 检查新容量是否超出了ArrayList所定义的最大容量，若超出则调比较 minCapacity 和 MAX_ARRAY_SIZE 的大小
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        
        // 给 elementData 扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    /**
     * 比较 minCapacity（所需的最小容量） 和 MAX_ARRAY_SIZE（最大容量）
     */
    private static int hugeCapacity(int minCapacity) {
        // 所需最小容量为负数，报OOM异常
        if (minCapacity < 0) 
            throw new OutOfMemoryError();
        // 如果 minCapacity 大于 MAX_ARRAY_SIZE 则新容量则为 Interger.MAX_VALUE，否则新容量大小为 MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

        
    /************************************* end *************************************/
    
    
    /**
     * 返回此列表中的元素数。
     */
    public int size() {
        return size;
    }

    /**
     * 判断列表中元素数是否为空
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 判断列表中是否含有某元素
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
     */
    public int indexOf(Object o) {
        // ArrayList中可以存储null值，这里获取的是null列表中第一次出现null值的位置
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i] == null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                // equals()方法比较
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-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;
    }

    /**
     * 返回此ArrayList实例的浅拷贝（虽然复制后新元素的地址不同，但都指向的是同一个元素）
     */
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            // Arrays.copyOf 功能是实现数组的复制，返回复制后的数组
            // 参数是被复制的数组和复制的长度
            v.elementData = Arrays.copyOf(elementData, size);
            // 列表修改次数重置为0
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // 这不应该发生，因为我们是可以克隆的
            throw new InternalError(e);
        }
    }

    /**
     * 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
     * 返回的数组将是【安全的】，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
     * 因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    /**
     * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
     * 返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
     * 否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
     * 如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
     *（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // 新建一个运行时类型的数组，但是ArrayList数组的内容
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
            // 调用System提供的arraycopy()方法实现数组之间的复制
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    /**
     * 获取指定位置的元素
     */
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * 返回此列表中指定位置的元素
     */
    public E get(int index) {
        // 检查是否index越界（fast-fail机制）
        rangeCheck(index);

        return elementData(index);
    }

    /**
     * 用指定的元素替换此列表中指定位置的元素
     */
    public E set(int index, E element) {
        // 对index进行界限检查
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        // 返回原来在这个位置的元素
        return oldValue;
    }

    /**
     * 将指定的元素追加到此列表的末尾
     */
    public boolean add(E e) {
        // 在此方法中实现动态扩容（内部会判断是否需要扩容）
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        // 这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }

    /**
     * 在此列表中的指定位置插入指定的元素
     * 先调用 rangeCheckForAdd 对 index 进行界限检查；然后调用 ensureCapacityInternal 方法保证 capacity 足够大
     * 再将从 index 开始之后的所有成员后移一个位置，将element插入index位置，最后size加1。
     */
    public void add(int index, E element) {
        // 对 index 进行界限检查
        // 与 rangeCheck 方法的区别在于，rangeCheck没有判断 index小于0的情况
        rangeCheckForAdd(index);
        
        // 在此方法中实现动态扩容（内部会判断是否需要扩容）
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        // 实质上是使用了数组复制方法，将 index 位置之后的所有值往后移1位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 给index位置赋值
        elementData[index] = element;
        // 数组长度要+1
        size++;
    }

    /**
     * 删除该列表中指定位置的元素。
     * 将任何后续元素移动到左侧（从其索引中减去一个元素）
     */
    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        // 使用数组复制方法，将 index 位置之后的所有值往前移1位
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 因为删除少了一个元素，所以原数组最后一个位置置为null
        elementData[--size] = null; // clear to let GC do its work
        // 返回从列表中删除的元素
        return oldValue;
    }

    /**
     * 从列表中删除指定元素的第一个出现（如果存在）
     * 如果列表不包含该元素，则它不会更改。
     * 如果此列表包含指定的元素则返回true
     */
    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++;

        // 把数组中所有的元素的值设为null
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        // 数组长度置0
        size = 0;
    }

    /**
     * 按指定集合的 Iterator 返回的顺序将指定集合中的所有元素追加到此列表的末尾
     */
    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 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;
    }

    /**
     * 从此列表中删除所有索引为fromIndex（含）和toIndex之间的元素。
     * 将任何后续元素移动到左侧（减少其索引）。
     */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

    /**
     * 检查给定的索引是否在范围内
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 检查给定的索引是否在范围内（考虑了index小于0的情况）
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 返回IndexOutOfBoundsException细节信息
     */
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    /**
     * 从此列表中删除指定集合中包含的所有元素。
     */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        // 如果此列表被修改则返回true
        return batchRemove(c, false);
    }

    /**
     * 仅保留此列表中包含在指定集合中的元素。
     * 换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
     */
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

Arrays.copyOf 是浅拷贝，源码浅看一下：

/**
 * @param original 要复制的数组
 * @param newLength 要返回的副本长度
 */
@SuppressWarnings("unchecked")
public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

/**
 * @param original 要复制的数组
 * @param newLength 要返回的副本长度
 * @param newType 要返回的副本类型
 */
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

2. 扩容机制分析

在 JDK8 中，ArrayList有三种初始化的方式，从上面的源码中可以看出来。

从上面的源码解读中可以知道，以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。

补充：JDK6 new 无参构造的 ArrayList 对象时，直接创建了长度是 10 的 Object[] 数组 elementData 。

以无参构造函数创建的 ArrayList 为例进行分析，先看add方法。

/**
 * 将指定的元素追加到此列表的末尾
 */
public boolean add(E e) {
    // 在此方法中实现动态扩容（内部会判断是否需要扩容）
    ensureCapacityInternal(size + 1);  // Increments modCount!!

    // 这里看到ArrayList添加元素的实质就相当于为数组赋值
    elementData[size++] = e;
    return true;
}

注意 ：JDK11 移除了 ensureCapacityInternal() 和 ensureExplicitCapacity() 方法

再看看ensureCapacityInternal方法

/**
 * 【核心】内部数组自动扩容方法
 * 
 * @param minCapacity 所需的最小容量
 */
private void ensureCapacityInternal(int minCapacity) {
    // 第一次给ArrayList新增元素的时候，在这里给elementData的容量赋初值为 10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
          // 取【默认的容量】和【传入所需的最小容量】两者之间最大值
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

可以看到当 要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，minCapacity 为 10。

如果调用 ensureCapacityInternal() 方法就一定会进入ensureExplicitCapacity() 方法：

/**
 * 判断是否需要进行扩容
 * 所需的最小容量 > 数组的长度，需要进行扩容
 * 所需的最小容量 <= 数组的长度，不需要进行扩容
 * 
 * @param minCapacity 所需的最小容量
 */
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // 如果所需的最小容量大于数组的长度，需要进行扩容
    if (minCapacity - elementData.length > 0)
        // grow为具体的扩容方法，调用此方法代表已经开始扩容
        grow(minCapacity);
}

经过分析：

• 当我们要 add 进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法 ，所以 minCapacity 此时为 10。此时，minCapacity - elementData.length > 0成立，所以会进入 grow(minCapacity) 方法。
• 当 add 第 2 个元素时，minCapacity 为 2，此时 elementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入 （执行）grow(minCapacity) 方法。
• 添加第 3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。

直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入 grow 方法进行扩容。

grow方法：

/**
 * ArrayList扩容的核心方法
 * 
 * @param minCapacity 所需的最小容量
 */
private void grow(int minCapacity) {
    // oldCapacity为旧数组容量
    int oldCapacity = elementData.length;

    // newCapacity为新容量
    // 将oldCapacity 右移一位，其效果相当于oldCapacity/2，所以这个运算表示新容量的大小扩展到旧容量大小的1.5倍
    // 位运算的速度远远快于整除运算，所以使用移位运算符进行计算
    int newCapacity = oldCapacity + (oldCapacity >> 1);

    // 检查新容量是否大于最小需要容量，若还是小于最小需要容量，就需要把最小需要容量当作数组的新容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    // 检查新容量是否超出了ArrayList所定义的最大容量，若超出则调比较 minCapacity 和 MAX_ARRAY_SIZE 的大小
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);

    // 给 elementData 扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

通过以上代码可以知道：

• 当 add 第 1 个元素时，oldCapacity 为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity（为 10）。但是第二个 if 判断不会成立，即 newCapacity 不比 MAX_ARRAY_SIZE 大，则不会进入 hugeCapacity 方法。数组容量为 10，add 方法中 return true，size 增为 1。
• 当 add 第 11 个元素进入 grow 方法时，newCapacity 为 15，比 minCapacity（为 11）大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 hugeCapacity 方法。数组容量扩为 15，add 方法中 return true，size 增为 11。
• 以此类推······

int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）

奇偶不同，比如 ：10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数。

位移运算符比那些普通运算符的运算要快很多，因为程序仅仅移动一下而已，不去计算，这样提高了效率，节省了资源

hugeCapacity() ：

/**
 * 比较 minCapacity（所需的最小容量） 和 MAX_ARRAY_SIZE（最大容量）
 */
private static int hugeCapacity(int minCapacity) {
    // 所需最小容量为负数，报OOM异常
    if (minCapacity < 0) 
        throw new OutOfMemoryError();
    // 如果 minCapacity 大于 MAX_ARRAY_SIZE 则新容量则为 Interger.MAX_VALUE，否则新容量大小为 MAX_ARRAY_SIZE
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

3. 关于fast-fail和迭代器

先来看看 ArrayList 中迭代器相关的源码解析。

/**
 * 返回的是一个顺序的从指定位置开始的列表迭代器。
 * 指定的索引指示第一个元素通过初始元素通过调用 ListIterator#next 返回。
 * 对 ListIterator#previous 的初始调用将返回具有指定索引减1的元素
 *
 * 返回的列表迭代器是fast-fail
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public ListIterator<E> listIterator(int index) {
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}

/**
 * 返回一个有所有元素的列表迭代器
 *
 * @see #listIterator(int)
 */
public ListIterator<E> listIterator() {
    return new ListItr(0);
}

/**
 * 返回一个以正确顺序遍历的迭代器
 *
 */
public Iterator<E> iterator() {
    return new Itr();
}

/**
 * AbstractList.Itr的优化
 */
private class Itr implements Iterator<E> {
    // 游标，返回下个元素的索引
    int cursor;       
    // 返回最后一个元素的索引，如果没有返回-1
    int lastRet = -1; 
    // modCount 表示数组当中数据改变的次数
    // modCount 是ArrayList类的变量，expectedModCount是Itr迭代器中的变量
    int expectedModCount = modCount;

    /**
     * 判断是否有下一个元素，如果cursor与size相等说明已经到了最后一个元素
     */
    public boolean hasNext() {
        return cursor != size;
    }

    /**
     * 获取下一个元素
     */
    @SuppressWarnings("unchecked")
    public E next() {
        // fast-fail 检查外部是否有列表长度变化 如果有则抛出异常
        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() {
        // 最后一个元素索引为-1抛出异常
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            // 调用 ArrayList 的remove方法实现
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            // 因为 remove 会改变 modCount 的值，因此需要将 expectedModCount 重新赋值
            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();
    }

    /**
     * fast-fail的体现，expectedModCount 如果与 modCount 不相等，则直接抛出异常
     * 所以 modCount 如果改变（即在使用迭代器遍历元素的时候，对列表长度进行了修改）会直接报错
     */
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

/**
 *  AbstractList.ListItr的优化
 */
private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        return (E) elementData[lastRet = i];
    }

    public void set(E e) {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();

        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

可以看到Itr类中几乎所有的方法中调用了checkForComodification()。迭代器在进行遍历的同时，如果modCount的值改变了，则会抛出ConcurrentModificationException异常。这种现象通常发生出现在并发的情况下，或者在迭代器进行迭代的时候，ArrayList使用了add或者remove操作的时候（ArrayList在add或者remove时，modCount都会进行改变，导致迭代器内的expectedModCount值与modCount值不一致）。

像这种通过迭代器遍历过程进行检查并且当发生不符合条件的情况下抛出异常的现象就称作fast-fail。

4. 扩展

4.1. System.arraycopy

含义：把一个数组中某一段字节数据放到另一个数组中。

/**
 * @param src 源数组
 * @param srcPos 源数组要复制的起始位置
 * @param dest 目的数组
 * @param desPos 目的数组放置的起始位置
 * @param length 复制的长度
 */
public static native void arraycopy(Object src,  
                                    int srcPos,
                                    Object dest,
                                    int destPos,
                                    int length);

举个例子：

int[] arr = { 1, 2, 3, 4, 5 };
int[] arr2 = { 5, 6,7, 8, 9 };

System.arraycopy(arr, 1, arr2, 0, 3);

// 运行结果：int[] arr2 = { 2, 3, 4, 8, 9 };

这个函数可以实现自己到自己复制。

4.2. 移位运算符

针对二进制进行的运算。

刚刚在ArrayList的源码，扩容的主要方法 grow 中出现了移位运算符：

// 扩容为原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);

4.2.1. 左移运算符 <<

先随便定义一个int类型的数int，十进制的 value = 733183670，转换成二进制在计算机中的表示如下：

value << 1，左移一位，即变成：

左移1位后换算成十进制的值为：1466367340，刚好是733183670的两倍，。所以在乘2操作时有的时候喜欢用左移运算符来替代。

value << 8，左移8位看一下：

左移8位后变成了十进制的值为：-1283541504，移动8位后，由于首位变成了1，也就是说成了负数，在使用中要考虑变成负数的情况。

根据这个规则，左移32位后，右边补上32个0值是不是就变成了十进制的0了？

答案是NO。当int类型进行左移操作时，左移位数大于等于32位操作时，会先求余（%）后再进行左移操作。

也就是说左移32位相当于不进行移位操作，左移40位相当于左移8位（40%32=8）。

当long类型进行左移操作时，long类型在二进制中的体现是64位的，因此求余操作的基数也变成了64，也就是说左移64位相当于没有移位，左移72位相当于左移8位（72%64=8）

double，float在二进制中的表现比较特殊，因此不能来进行移位操作，报错，编译不过。

注意：其它几种整形byte，short移位前会先转换为int类型（32位）再进行移位。

【总结一下】

左移 << 其实很简单，也就是说丢弃左边指定位数，右边补0。

4.2.2. 右移运算符 >>

还是这个数：733183670

value >> 1，右移一位

右移1位后换算成十进制的值为：366591835，刚好是733183670的一半， 所以在除2操作时有的时候喜欢用右移运算符来替代。

value >> 8，右移8位看一下：

和左移一样，int类型移位大于等于32位时，long类型大于等于64位时，会先做求余处理再位移处理，byte，short移位前会先转换为int类型（32位）再进行移位。

【总结一下】

右移运算符 >> 的运算规则也很简单，丢弃右边指定位数，左边补上符号位。

4.2.3. 无符号右移运算符 >>>

无符号右移运算符 >>> 和右移运算符 >> 是一样的，只不过右移时左边是补上符号位，而无符号右移运算符是补上0，也就是说，对于正数移位来说等同于：>>，负数通过此移位运算符能移位成正数。以 -733183670>>>8 为例：

【总结】

无符号右移运算符 >> 的运算规则也很简单，丢弃右边指定位数，左边补上0。

5. 相关面试题

5.1. ArrayList中elementData为何被transient修饰？

transient 用来表示一个域不是该对象序行化的一部分，当一个对象被序行化的时候，transient修饰的变量的值不包括在序行化的表示中。

可是ArrayList又是可序行化的类，elementData是ArrayList具体存放元素的成员，用transient来修饰elementData，岂不是反序列化后的ArrayList丢失了原先的元素？

玄机在writeObject和readObject这两个方法当中。看一下源码

/**
 * 将ArrayList实例的状态保存成一个流（也就是序列化它）
 */
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();
    }
}

/**
 * 从流重新构建ArrayList（也就是反序列化）
 */
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) {
        // 类似clone，根据数组大小分配容量
        ensureCapacityInternal(size);

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

ArrayList在序列化的时候会调用writeObject，直接将size和element写入ObjectOutputStream；反序列化时调用readObject，从ObjectInputStream获取size和element，再恢复到elementData。

为何要采用上诉的方式来实现序列化？

因为elementData是一个缓存数组，它一般会预留一些容量，等容量不足时再扩充容量，那么有些空间可能就没有实际存储元素，采用上诉的方式来实现序列化时，就能够保证只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间。

5.2. ArrayList 与 LinkedList 区别？

• 是否保证线程安全

  ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；

• 底层数据结构

  Arraylist 底层使用的是 Object 数组；LinkedList 底层使用的是 双向链表 数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！）

• 插入和删除是否受元素位置的影响

  • ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
  • LinkedList 采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话（(add(int index, E element)） 时间复杂度近似为o(n))因为需要先移动到指定位置再插入。

• 是否支持快速随机访问

  LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。

• 内存空间占用

  ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）

5.3. ArrayList 和 Vector 的区别？

• ArrayList 是 List 的主要实现类，底层使用 Object[ ]存储，适用于频繁的查找工作，线程不安全
• Vector 是 List 的古老实现类，底层使用 Object[ ]存储，线程安全的。

5.4. ArrayList数组最大长度为什么是Integer.MAX_VALUE-8？

-8的位置是存放数组在内存中头部信息。

5.5. add方法与addAll方法

ArrayList空数组使用add新增元素，将元素加到11时，ArrayList的容量会自动扩容到15。

而如果使用addAll方法直接给空的ArrayList加入一个长度为11的数组时，ArrayList的容量变成了11而不是15。因为使用addAll方法时，list不会因为扩容后容量不够而再次扩容，而是会进行一次性的扩容，一步到位。也就是说，使用addAll方法，没有元素时，扩容为 Math.max(10, 实际元素个数)，有元素时为 Math.max(原容量的1.5 倍, 实际元素个数)。