ArrayList 概述

• ArrayList 是一种变长的集合类，底层是基于数组来实现的，所以 ArrayList 查询效率高、增删效率低
• ArrayList 集合中的元素是有序、可重复的，且可以存储 null 空值
• 当每次向 ArrayList 容器中添加元素时，会进行容量检查：当往 ArrayList 中添加的元素数量大于其底层数组容量时，会通过扩容机制重新生成一个更大容量的数组，然后把旧数组上面的数据复制进新数组
• ArrayList 是线程不安全的。在并发环境下，多个线程同时操作 ArrayList，会引发不可预知的错误。所以在多线程环境下可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类来替代 ArrayList 类，或者使用 Collections.synchronizedList(List l) 返回一个线程安全的 ArrayList 类

属性

// 容器中真正存放元素的地方，使用 transient 是为了不序列化这个字段。elementData 数组的长度指的是容器的容量
transient Object[] elementData;
// 容器中真正存储的元素个数
private int size;
// 定义默认空容量的数组：当使用 new ArrayList() 创建容器时，会将这个空数组直接赋值给 elementData
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 默认的容量大小：使用 new ArrayList() 创建容器后，并往容器中添加第一个元素时才会使用这个默认容量进行初始化
private static final int DEFAULT_CAPACITY = 10;
// 定义空容量的数组：当使用 new ArrayList(0) 创建容器时，会使用这个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

构造方法

ArrayList()

// 无参的构造方法
public ArrayList() {
  // 当直接创建ArrayList时，elementData被赋予了默认空容量的数组，此时ArrayList容器的容量是0
  this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList(int)

// 传容量的构造方法：根据传入的数值大小，创建指定长度的数组
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);
  }
}

• 当 initialCapacity > 0 时，会在堆上 new 一个大小为 initialCapacity 的数组，然后将其引用赋给 elementData，此时 ArrayList 的容量为 initialCapacity，元素个数 size 为默认值 0
• 当 initialCapacity = 0 时，elementData 被赋予了默认空数组，因为其被 final 修饰了，所以此时 ArrayList 的容量为 0，元素个数 size 为默认值 0
• 当 initialCapacity < 0 时，会抛出异常

ArrayList(Collection)

// 传入Collection元素列表的构造方法
public ArrayList(Collection<? extends E> c) {
  Object[] a = c.toArray();
  if ((size = a.length) != 0) {
    if (c.getClass() == ArrayList.class) {
      elementData = a;
    } else {
      elementData = Arrays.copyOf(a, size, Object[].class);
    }
  } else {
    // replace with empty array.
    elementData = EMPTY_ELEMENTDATA;
  }
}

将参数集合转化为一个 Object 类型的数组：

• 如果参数集合转换为数组后的数组长度为 0，会初始化 elementData 为空数组，此时 ArrayList 的容量是 0，元素个数 size 为 0
• 如果参数集合转换为数组后的数组长度不等于 0
  • 如果参数集合的类型是 ArrayList，则直接将参数赋值给 elementData
  • 否则，将参数数组的数组类型转换为 Object 对象数组的数组类型，并赋值给 elementData

添加元素

当我们探讨扩容时，肯定要从ArrayList的add方法走起

add(E)

// 在容器尾部插入指定元素
public boolean add(E e) {
  // 添加元素之前，首先需要确定集合的容量（检测集合是否需要扩容）
  ensureCapacityInternal(size + 1);
  // 将指定元素插入容器尾部
  elementData[size++] = e;
  return true;
}
// 确保容器内部的容量：即容器扩容的入口方法
private void ensureCapacityInternal(int minCapacity) { // minCapacity是集合当前大小+1
  ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算并得到容器的最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
  // 如果elementData是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则从size+1的值和默认值10中取最大值
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    return Math.max(DEFAULT_CAPACITY, minCapacity);
  }
  // 如果elementData不为空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则返回size+1
  return minCapacity;
}
// 确保elementData数组的容量足够存放新加入的元素，若不够，要扩容
private void ensureExplicitCapacity(int minCapacity) {
  // moCount是记录ArrayList被修改次数的，该变量主要是用来实现fail-fast机制
  modCount++;
  // 如果添加元素后的集合最小容量大于当前ArrayList内部数组的长度，就需要对内部数组elementData扩容
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}
// 扩容的实际方法：该方法是用来确保ArrayList至少能存储minCapacity个元素
private void grow(int minCapacity) {
  // 扩容前的elementData容量
  int oldCapacity = elementData.length;
  // 获取旧容量的1.5倍赋值给一个新容量变量（oldCapacity右移一位，等于除以二）
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  if (newCapacity - minCapacity < 0) // 如果扩容后的新容量比实际需要的容量还小，则以实际需要的容量为准
    newCapacity = minCapacity;
  if (newCapacity - MAX_ARRAY_SIZE > 0) // 如果新容量超过容器支持的最大容量了，则使用最大容量
    newCapacity = hugeCapacity(minCapacity);
  // 使用 Arrays.copyOf() 方法将原数组的值拷贝到一个大小为newCapacity的新数组
  elementData = Arrays.copyOf(elementData, newCapacity);
}
// 计算最大的容量
private static int hugeCapacity(int minCapacity) {
  if (minCapacity < 0) // 大小溢出
    throw new OutOfMemoryError();
  // 如果所需最小容量minCapacity大于数组最大的长度，则取Integer的最大值，否则取数组最大长度
  return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
// 允许分配的最大数组大小
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

add(int, E)

// 在集合指定索引 index 位置处插入指定元素 element
public void add(int index, E element) {
  // 检查是否越界
  rangeCheckForAdd(index);
  // 检测是否需要扩容
  ensureCapacityInternal(size + 1);
  // 将 index 及其之后的所有元素都向后移一位
  System.arraycopy(elementData, index, elementData, index + 1, size - index);
  // 将新元素插入至index的位置
  elementData[index] = element;
  size++;
}
private void rangeCheckForAdd(int index) {
  if (index > size || index < 0)
    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

ArrayList 的扩容机制

扩容可分为两种情况：

第一种情况：当 ArrayList 的容量为 0 时，此时添加元素的话，需要扩容，三种构造方法创建的 ArrayList 在扩容时略有不同

• 无参构造，创建 ArrayList 后容量为 0，添加第一个元素后，容量变为 10，此后若需要扩容，则正常扩容
• 传容量构造，当参数为 0 时，创建 ArrayList 后容量为 0，添加第一个元素后，容量为 1，此时 ArrayList 是满的，下次添加元素时需正常扩容
• 传列表构造，当列表为空时，创建 ArrayList 后容量为 0，添加第一个元素后，容量为 1，此时 ArrayList 是满的，下次添加元素时需正常扩容

第二种情况：当 ArrayList 的容量大于 0，并且集合是满的时，此时添加元素的话，进行正常扩容，每次扩容到原来的 1.5 倍

删除元素

不同于插入操作，ArrayList 没有无参删除方法。所以其只能删除指定位置的元素或删除指定元素，这样就无法避免移动元素（除非从元素序列的尾部删除）

remove(int)

// 删除指定位置的元素
public E remove(int index) {
  // 检查是否数组越界
  rangeCheck(index);
  // moCount是记录ArrayList被修改次数的，该变量主要是用来实现fail-fast机制
  modCount++;
  // 获取index索引处的元素
  E oldValue = elementData(index);
  int numMoved = size - index - 1;
  if (numMoved > 0)
    // 如果 index 不是最后一位，则将 index + 1 及之后的元素向前移动一位，覆盖被删除值
    System.arraycopy(elementData, index + 1, elementData, index, numMoved);
  // 将最后一个元素置空，并将 size 值减 1
  elementData[--size] = null;
  // 返回旧值
  return oldValue;
}
private void rangeCheck(int index) {
  if (index >= size)
    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
  return (E) elementData[index];
}

remove(Object)

// 删除指定元素：若元素重复，则只删除下标最小的元素
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) {
  // moCount是记录ArrayList被修改次数的，该变量主要是用来实现fail-fast机制
  modCount++;
  int numMoved = size - index - 1;
  if (numMoved > 0)
    // 如果 index 不是最后一位，则将 index + 1 及之后的元素向前移动一位，覆盖被删除值
    System.arraycopy(elementData, index + 1, elementData, index, numMoved);
  // 将最后一个元素置空，并将 size 值减 1
  elementData[--size] = null;
}

更新元素：set(int, E)

public E set(int index, E element) {
  rangeCheck(index); // 检查是否数组越界
  E oldValue = elementData(index); // 获取index索引处的旧值
  elementData[index] = element; // 将指定索引处的元素替换为 element
  return oldValue; // 返回旧值
}

查询元素：get()

// 获取指定索引处的元素
public E get(int index) {
  rangeCheck(index); // 检查是否越界
  return elementData(index); // 获取并返回index索引处的元素
}
private void rangeCheck(int index) {
  if (index >= size)
    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
  return (E) elementData[index];
}