• 该文章收录于：JAVA面试题整理
• 其他相关链接：ArrayList源码分析

ArrayList创建和add等各种api使用原理

• ArrayList 允许空值和重复元素，当往 ArrayList 中添加的元素数量大于其底层数组容量时，其会通过扩容机制重新生成一个更大的数组。
• ArrayList 是非线程安全类，并发环境下，多个线程同时操作 ArrayList，会引发不可预知的异常或错误。

ArrayList创建源码

• 带有初始容量的构造方法

// Shared empty array instance used for empty instances.
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Constructs an empty list with the specified initial capacity.
 * @param  initialCapacity  the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
public ArrayList(int initialCapacity) {
    // 参数大于0，elementData初始化为initialCapacity大小的数组，即根据传入的参数大小创建数组
    if (initialCapacity > 0) {
        this.elementData = new Object\[initialCapacity\];
    // 参数等于0，创建空数组
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    // 否则抛出异常，参数异常，初始化容量异常
    } else {
	throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); 
    }
}

• 无参构造方法，即使用默认的size为10的空数组，

在构造方法中没有对数组长度进行设置，会在后续调用add方法的时候进行扩容

/** 
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY\_ELEMENTDATA to know how much to inflate when
 * first element is added. 
 */ 
private static final Object[] DEFAULTCAPACITY\_EMPTY_ELEMENTDATA = {};


/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA;
}

• 参数为集合的构造方法，将一个参数为Collection的集合转变为ArrayList（实际上就是将集合中的元素换为了数组的形式）。

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param c the collection whose elements are to be placed into this list 
 * @throws NullPointerException if the specified collection is null
 */
 public ArrayList(Collection<? extends E> c) {
    // 如果传入的集合为空，则c.toArray()抛出空指针异常
    elementData = c.toArray();
    // 如果传入的数组容量不为0 而且toArray之后不为对象数组的话，就通过数组复制修改为底层结构是对象数组的集合
    if ((size = elementData.length) != 0) {
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class) {
       elementData = Arrays.copyOf(elementData, size, Object\[\].class);
    } else {
    // replace with empty array.
      this.elementData = EMPTY_ELEMENTDATA;
    }
 }

ArrayList的add方法源码

/**
 * Appends the specified element to the end of this list. 
 * 将指定元素添加到list的结尾
 * @param e element to be appended to this list 
 * @return <tt>true</tt> (as specified by {@link Collection#add})
 */
public boolean add(E e) { 
   // 添加前先要扩容数组 
   ensureCapacityInternal(size + 1); 
   // Increments modCount!!
   // 将元素添加到数组最后一个位置 
   elementData\[size++\] = e; return true; 
 }
// ensureCapacityInternal方法分析
private void ensureCapacityInternal(int minCapacity) {
   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算出最少需要的容量 
private static int calculateCapacity(Object[] elementData, int minCapacity) { 
  // 这里就是判断elementData数组是不是为空数组     
  //（使用的无参构造的时候，elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA）
  // 如果是，那么比较size+1(第一次调用add的时候size+1=1)和DEFAULT\_CAPACITY（为10）
  // 那么显然容量为10
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    return Math.max(DEFAULT_CAPACITY, minCapacity);
  }
  return minCapacity;
} 
private void ensureExplicitCapacity(int minCapacity) {
  modCount++;
  // overflow-conscious code 最少需要的容量大于元素总的数量
  if (minCapacity - elementData.length > 0) 
    // 执行扩容方法 
    grow(minCapacity);
  }

/**最大容量
-   The maximum size of array to allocate.
-   Some VMs reserve some header words in an array.
-   Attempts to allocate larger arrays may result in
-   OutOfMemoryError: Requested array size exceeds VM limit 
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
-   Increases the capacity to ensure that it can hold at least the
-   number of elements specified by the minimum capacity argument.
-   扩容函数，保证扩容后的容量大于需要的最小容量，又小于Integer.MAX_VALUE
-   @param minCapacity the desired minimum capacity 
*/ 
private void grow(int minCapacity) {
   //获取旧数组的容量 
   int oldCapacity = elementData.length;

   // 新数组的容量 = old+old/2,即扩容1.5倍 
   int newCapacity = oldCapacity + (oldCapacity >> 1);

   // 如果新数组的容量比要求的最低容量还少，就使用最低容量作为新数组的容量 
   if (newCapacity - minCapacity < 0) newCapacity = minCapacity;

   // 如果旧数组扩容1.5倍之后，比Integer.MAX_VALUE-8大，使用hugeCapacity比较二者
   // 如果要求的最小容量大于Integer.MAX_VALUE-8就使用Integer.MAX_VALUE作为扩容后的容量，否则使用Integer.MAX_VALUE-8作为扩容后的容量
   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);     
}

    // 判断得出新数组的容量需要扩容到多少 
private static int hugeCapacity(int minCapacity) {
   if (minCapacity < 0) throw new OutOfMemoryError();
    // 对minCapacity和MAX_ARRAY_SIZE进行比较
    // 若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
    // 若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
    // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; 
}

当 要 add 进第1个元素时，minCapacity为(size+1=0+1=)1，在Math.max()方法比较后，minCapacity 为10。 然后紧接着调用ensureExplicitCapacity更新modCount的     值，并判断是否需要扩容
add方法执行流程总结​ 我们用一幅图来简单梳理一下，当使用无参构造的时候，在第一次调用add方法之后的执行流程

这是第一次调用add方法的过程，当扩容值capacity为10之后，

• 继续添加第2个元素（先注意调用ensureCapacityInternal方法传递的参数为size+1=1+1=2）

• 在ensureCapacityInternal方法中，elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA不成立，所以直接执行ensureExplicitCapacity方法

• ensureExplicitCapacity方法中minCapacity为刚刚传递的2，所以第二个if判断（2-10=-8）不会成立，即newCapacity 不比 MAX_ARRAY_SIZE大，则不会进入 grow 方法。数组容量为10，add方法中 return true,size增为1。

• 假设又添加3、4......10个元素（其中过程类似，但是不会执行grow扩容方法）

• 当add第11个元素时候，会进入grow方法时，计算newCapacity为15，比minCapacity（为10+1=11）大，第一个if判断不成立。新容量没有大于数组最大size，不会进入hugeCapacity方法。数组容量扩为15，add方法中return true,size增为11。

add(int index,E element)方法

//在元素序列 index 位置处插入
public void add(int index, E element) {
    rangeCheckForAdd(index); //校验传递的index参数是不是合法
    // 1. 检测是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 2. 将 index 及其之后的所有元素都向后移一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 3. 将新元素插入至 index 处
    elementData[index] = element;
    size++;
}
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0) //这里判断的index>size（保证数组的连续性），index小于0
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

add(int index, E element)方法（在元素序列指定位置（假设该位置合理）插入）的过程大概是下面这些

将新元素插入至序列指定位置，需要先将该位置及其之后的元素都向后移动一位，为新元素腾出位置。这个操作的时间复杂度为，频繁移动元素可能会导致效率问题，特别是集合中元素数量较多时。在日常开发中，若非所需，我们应当尽量避免在大集合中调用第二个插入方法。

ArrayList的remove方法

1、remove(int index) 按照下标删除

public E remove(int index) {
    rangeCheck(index); //校验下标是否合法（如果index>size，旧抛出IndexOutOfBoundsException异常）
    modCount++;//修改list结构，就需要更新这个值
    E oldValue = elementData(index); //直接在数组中查找这个值

    int numMoved = size - index - 1;//这里计算所需要移动的数目
    //如果这个值大于0 说明后续有元素需要左移(size=index+1)
    //如果是0说明被移除的对象就是最后一位元素(不需要移动别的元素)
    if (numMoved > 0)
        //索引index只有的所有元素左移一位  覆盖掉index位置上的元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //移动之后，原数组中size位置null
    elementData[--size] = null; // clear to let GC do its work
    //返回旧值
    return oldValue;
}

// src:源数组 
// srcPos:从源数组的srcPos位置处开始移动 
// dest:目标数组 
// desPos:源数组的srcPos位置处开始移动的元素，这些元素从目标数组的desPos处开始填充 
// length:移动源数组的长度 public static native void (Object src, int srcPos, Object dest, int destPos,int length);

删除过程如下图所示

2、remove(Object o) 按照元素删除，会删除和参数匹配的第一个元素

public boolean remove(Object o) {
     //如果元素是null 遍历数组移除第一个null
     if (o == null) {
           for (int index = 0; index < size; index++)
              if (elementData[index] == null) {
                  //遍历找到第一个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
}

ArrayList的其他方法

ensureCapacity方法

最好在 add 大量元素之前用 ensureCapacity 方法，以减少增量从新分配的次数

    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)? 0
            : DEFAULT_CAPACITY;
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

ArrayList总结

（1）ArrayList 是一种变长的集合类，基于定长数组实现，使用默认构造方法初始化出来的容量是10（1.7之后都是延迟初始化，即第一次调用add方法添加元素的时候才将elementData容量初始化为10）。

（2）ArrayList 允许空值和重复元素，当往 ArrayList 中添加的元素数量大于其底层数组容量时，其会通过扩容机制重新生成一个更大的数组。ArrayList扩容的长度是原长度的1.5倍

（3）由于 ArrayList 底层基于数组实现，所以其可以保证在 O(1) 复杂度下完成随机查找操作。

（4）ArrayList 是非线程安全类，并发环境下，多个线程同时操作 ArrayList，会引发不可预知的异常或错误。

（5）顺序添加很方便

（6）删除和插入需要复制数组，性能差（可以使用LinkindList）

（7）Integer.MAX_VALUE - 8 ：主要是考虑到不同的JVM,有的JVM会在加入一些数据头,当扩容后的容量大于MAX_ARRAY_SIZE,我们会去比较最小需要容量和MAX_ARRAY_SIZE做比较,如果比它大, 只能取Integer.MAX_VALUE,否则是Integer.MAX_VALUE -8。 这个是从jdk1.7开始才有