ArrayList 源码解析

ArrayList概述

ArrayList实现了List接口，并重写了所有方法。可以存储任何数据类型，包括null，数据可重复，线程不安全

类结构

主要成员变量

transient Object[] elementData; // Object类型数组，用来存放ArrayList数据
private int size;//表述数组元素的个数。并非数组容量

主要常量

private static final int DEFAULT_CAPACITY = 10;//默认初始化容量
private static final Object[] EMPTY_ELEMENTDATA = {};//空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//空数组，区别于EMPTY_ELEMENTDATA

相关知识

Arrays类的copyOf(U[] original, int newLength, Class<? extends T[]> newType)方法用于复制指定数组original到新数组，新数组的长度为newLength，新数组元素类型为newType。

0. 如果新数组的长度大于旧数组，那么多出的那部分用null填充；
1. 如果新数组的长度小于旧数组，那么少的那部分直接截取掉。

源码

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

ArrayList构造函数

空参构造函数

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

有参构造函数

第一种；创建容量大小为initialCapacity的ArrayList

//创一个初始化容量为initialCapacity大小的ArrayList
public ArrayList(int initialCapacity) {
  if (initialCapacity > 0) {
    this.elementData = new Object[initialCapacity];
    //如果initialCapacity=0，那就创建一个容量为10的
  } else if (initialCapacity == 0) {
    this.elementData = EMPTY_ELEMENTDATA;
  } else {
    //小于0报错
    throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
  }
}

第二种；创建一个包含指定集合c数据的ArrayList

public ArrayList(Collection<? extends E> c) {
  Object[] a = c.toArray();
  if ((size = a.length) != 0) {
    if (c.getClass() == ArrayList.class) {
      elementData = a;
    } else {
      //为什么用Arrays.copyOf()?因为有时候toArray()方法返回的不是Object[].class
      elementData = Arrays.copyOf(a, size, Object[].class);
    }
  } else {
    // replace with empty array.
    elementData = EMPTY_ELEMENTDATA;
  }
}

为什么用Arrays.copyOf()?因为有时候toArray()方法返回的不是Object[].class

//这个例子说明，toArray();有时候返回的不是Object[].class
public static void main(String[] args) {
  Long[] array1 = {1L, 2L};
  List<Long> list1 = Arrays.asList(array1);
  Object[] array2 = list1.toArray();
  System.out.println(array2.getClass() == Object[].class); // false

  List<Long> list2 = new ArrayList<>();
  System.out.println(list2.toArray().getClass() == Object[].class); // true
}

add(E e) 尾部添加元素

public boolean add(E e) {
  // 用于确定数组容量，e=hello，size=0
  ensureCapacityInternal(size + 1);  // Increments modCount!!
  // 末尾添加元素，然后size递增1
  elementData[size++] = e;
  return true;
}
private void ensureCapacityInternal(int minCapacity) { // minCapacity=1,elementData={}
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // DEFAULT_CAPACITY=10，minCapacity=1，故返回10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) { // minCapacity=10
    modCount++;

    // minCapacity=10，elementData.length=0，所以调用grow方法扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) { //minCapacity=10
    // oldCapacity=0
    int oldCapacity = elementData.length;
    // newCapacity为oldCapacity的1.5倍，这里为0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // newCapacity=0，minCapacity=10，所以该条件成立
    if (newCapacity - minCapacity < 0)
        // newCapacity=10
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制到新数组，数组容量为10
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    // MAX_ARRAY_SIZE常量值为Integer.MAX_VALUE - 8，通过
    // 这段逻辑我们可以知道，ArrayList最大容量为Integer.MAX_VALUE
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

通过上面源码分析我们可以知道：

0. 任何一个空的ArrayList在添加第一个元素时，内部数组容量将被扩容为10；
1. 扩容时，newCapacity为oldCapacity的1.5倍；
2. 数组容量最大为Integer.MAX_VALUE；
3. 尾部添加元素不用移动任何元素，所以速度快。