用大白话告诉你ArrayList的底层原理

一、ArrayList的数据结构

ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对ArrayList的所有操作底层都是基于数组的。

二、ArrayList的线程安全性

对ArrayList进行添加元素的操作的时候是分两个步骤进行的，即第一步先在object[size]的位置上存放需要添加的元素；第二步将size的值增加1。由于这个过程在多线程的环境下是不能保证具有原子性的，因此ArrayList在多线程的环境下是线程不安全的。

具体举例说明：在单线程运行的情况下，如果Size = 0，添加一个元素后，此元素在位置 0，而且Size=1；而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增 加 Size 的值。  那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而Size却等于 2。这就是“线程不安全”了。

如果非要在多线程的环境下使用ArrayList，就需要保证它的线程安全性，通常有两种解决办法：第一，使用synchronized关键字；第二，可以用Collections类中的静态方法synchronizedList();对ArrayList进行调用即可。

三、ArrayList的继承关系

ArrayList继承AbstractList抽象父类，实现了List接口（规定了List的操作规范）、RandomAccess（可随机访问）、Cloneable（可拷贝）、Serializable（可序列化）。

四、ArrayList的主要成员变量

• private static final int DEFAULT_CAPACITY = 10；

当ArrayList的构造方法中没有显示指出ArrayList的数组长度时，类内部使用默认缺省时对象数组的容量大小，为10。

• private static final Object[] EMPTY_ELEMENTDATA = {};

当ArrayList的构造方法中显示指出ArrayList的数组长度为0时，类内部将EMPTY_ELEMENTDATA 这个空对象数组赋给elemetData数组。

• private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

当ArrayList的构造方法中没有显示指出ArrayList的数组长度时，类内部使用默认缺省时对象数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

• transient Object[] elemetData;

ArrayList的底层数据结构，只是一个对象数组，用于存放实际元素，并且被标记为transient，也就意味着在序列化的时候此字段是不会被序列化的。

• private int size;

实际ArrayList中存放的元素的个数，默认时为0个元素。

• private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE – 8;

ArrayList中的对象数组的最大数组容量为Integer.MAX_VALUE – 8。

1.  
   public class ArrayList<E> extends AbstractList<E>
2.  
   implements List<E>, RandomAccess, Cloneable, java.io.Serializable
3.  
   {
4.  
   // 版本号
5.  
   private static final long serialVersionUID = 8683452581122892189L;
6.  
   // 缺省容量
7.  
   private static final int DEFAULT_CAPACITY = 10;
8.  
   // 空对象数组
9.  
   private static final Object[] EMPTY_ELEMENTDATA = {};
10.  
    // 缺省空对象数组
11.  
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
12.  
    // 元素数组
13.  
    transient Object[] elementData;
14.  
    // 实际元素大小，默认为0
15.  
    private int size;
16.  
    // 最大数组容量
17.  
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
18.  
    }

五、ArrayList的构造方法

• 无参构造方法

对于无参构造方法，将成员变量elementData的值设为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

1.  
   public ArrayList() {
2.  
   // 无参构造函数，设置元素数组为空
3.  
   this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
4.  
   }

• int类型参数构造方法

参数为希望的ArrayList的数组的长度，initialCapacity。首先要判断参数initialCapacity与0的大小关系：

如果initialCapacity大于0，则创建一个大小为initialCapacity的对象数组赋给elementData。

如果initialCapacity等于0，则将EMPTY_ELEMENTDATA赋给elementData。

如果initialCapacity小于0，抛出异常（非法的容量）。

1.  
   public ArrayList(int initialCapacity) {
2.  
   if (initialCapacity > 0) { // 初始容量大于0
3.  
   this.elementData = new Object[initialCapacity]; // 初始化元素数组
4.  
   } else if (initialCapacity == 0) { // 初始容量为0
5.  
   this.elementData = EMPTY_ELEMENTDATA; // 为空对象数组
6.  
   } else { // 初始容量小于0，抛出异常
7.  
   throw new IllegalArgumentException("Illegal Capacity: "+
8.  
   initialCapacity);
9.  
   }
10.  
    }

 

• Collection<? extends E>类型构造方法

第一步，将参数中的集合转化为数组赋给elementData；

第二步，参数集合是否是空。通过比较size与第一步中的数组长度的大小。

第三步，如果参数集合为空，则设置元素数组为空，即将EMPTY_ELEMENTDATA赋给elementData；

第四步，如果参数集合不为空，接下来判断是否成功将参数集合转化为Object类型的数组，如果转化成Object类型的数组成功，则将数组进行复制，转化为Object类型的数组。

1.  
   public ArrayList(Collection<? extends E> c) { // 集合参数构造函数
2.  
   elementData = c.toArray(); // 转化为数组
3.  
   if ((size = elementData.length) != 0) { // 参数为非空集合
4.  
   if (elementData.getClass() != Object[].class) // 是否成功转化为Object类型数组
5.  
   elementData = Arrays.copyOf(elementData, size, Object[].class); // 不为Object数组的话就进行复制
6.  
   } else { // 集合大小为空，则设置元素数组为空
7.  
   this.elementData = EMPTY_ELEMENTDATA;
8.  
   }
9.  
   }

六、ArrayList的add()方法

在add()方法中主要完成了三件事：首先确保能够将希望添加到集合中的元素能够添加到集合中，即确保ArrayList的容量（判断是否需要扩容）；然后将元素添加到elementData数组的指定位置；最后将集合中实际的元素个数加1。

1.  
   public boolean add(E e) { // 添加元素
2.  
   ensureCapacityInternal(size + 1); // Increments modCount!!
3.  
   elementData[size++] = e;
4.  
   return true;
5.  
   }

七、ArrayList的扩容机制

ArrayList的扩容主要发生在向ArrayList集合中添加元素的时候。由add()方法的分析可知添加前必须确保集合的容量能够放下添加的元素。主要经历了以下几个阶段：

第一，在add()方法中调用ensureCapacityInternal(size + 1)方法来确定集合确保添加元素成功的最小集合容量minCapacity的值。参数为size+1，代表的含义是如果集合添加元素成功后，集合中的实际元素个数。换句话说，集合为了确保添加元素成功，那么集合的最小容量minCapacity应该是size+1。在ensureCapacityInternal方法中，首先判断elementData是否为默认的空数组，如果是，minCapacity为minCapacity与集合默认容量大小中的较大值。

第二，调用ensureExplicitCapacity(minCapacity)方法来确定集合为了确保添加元素成功是否需要对现有的元素数组进行扩容。首先将结构性修改计数器加一；然后判断minCapacity与当前元素数组的长度的大小，如果minCapacity比当前元素数组的长度的大小大的时候需要扩容，进入第三阶段。

第三，如果需要对现有的元素数组进行扩容，则调用grow(minCapacity)方法，参数minCapacity表示集合为了确保添加元素成功的最小容量。在扩容的时候，首先将原元素数组的长度增大1.5倍（oldCapacity + (oldCapacity >> 1)），然后对扩容后的容量与minCapacity进行比较：① 新容量小于minCapacity，则将新容量设为minCapacity；②新容量大于minCapacity，则指定新容量。最后将旧数组拷贝到扩容后的新数组中。

1.  
   private void ensureCapacityInternal(int minCapacity) {
2.  
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 判断元素数组是否为空数组
3.  
   minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); // 取较大值
4.  
   }
5.  
    
6.  
   ensureExplicitCapacity(minCapacity);
7.  
   }

 

1.  
   private void ensureExplicitCapacity(int minCapacity) {
2.  
   // 结构性修改加1
3.  
   modCount++;
4.  
   if (minCapacity - elementData.length > 0)
5.  
   grow(minCapacity);
6.  
   }

1.  
   private void grow(int minCapacity) {
2.  
   int oldCapacity = elementData.length; // 旧容量
3.  
   int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量为旧容量的1.5倍
4.  
   if (newCapacity - minCapacity < 0) // 新容量小于参数指定容量，修改新容量
5.  
   newCapacity = minCapacity;
6.  
   if (newCapacity - MAX_ARRAY_SIZE > 0) // 新容量大于最大容量
7.  
   newCapacity = hugeCapacity(minCapacity); // 指定新容量
8.  
   // 拷贝扩容
9.  
   elementData = Arrays.copyOf(elementData, newCapacity);
10.  
    }

八、ArrayList的set(int index,E element)方法

set(int index, E element)方法的作用是指定下标索引处的元素的值。在ArrayList的源码实现中，方法内首先判断传递的元素数组下标参数是否合法，然后将原来的值取出，设置为新的值，将旧值作为返回值返回。

1.  
   public E set(int index, E element) {
2.  
   // 检验索引是否合法
3.  
   rangeCheck(index);
4.  
   // 旧值
5.  
   E oldValue = elementData(index);
6.  
   // 赋新值
7.  
   elementData[index] = element;
8.  
   // 返回旧值
9.  
   return oldValue;
10.  
    }

 

九、ArrayList的indexOf(Object o)方法

indexOf(Object o)方法的作用是从头开始查找与指定元素相等的元素，如果找到，则返回找到的元素在元素数组中的下标，如果没有找到返回-1。与该方法类似的是lastIndexOf(Object o)方法，该方法的作用是从尾部开始查找与指定元素相等的元素。

查看该方法的源码可知，该方法从需要查找的元素是否为空的角度分为两种情况分别讨论。这也意味着该方法的参数可以是null元素，也意味着ArrayList集合中能够保存null元素。方法实现的逻辑也比较简单，直接循环遍历元素数组，通过equals方法来判断对象是否相同，相同就返回下标，找不到就返回-1。这也解释了为什么要把情况分为需要查找的对象是否为空两种情况讨论，不然的话空对象调用equals方法则会产生空指针异常。

1.  
   // 从首开始查找数组里面是否存在指定元素
2.  
   public int indexOf(Object o) {
3.  
   if (o == null) { // 查找的元素为空
4.  
   for (int i = 0; i < size; i++) // 遍历数组，找到第一个为空的元素，返回下标
5.  
   if (elementData[i]==null)
6.  
   return i;
7.  
   } else { // 查找的元素不为空
8.  
   for (int i = 0; i < size; i++) // 遍历数组，找到第一个和指定元素相等的元素，返回下标
9.  
   if (o.equals(elementData[i]))
10.  
    return i;
11.  
    }
12.  
    // 没有找到，返回空
13.  
    return -1;
14.  
    }

十、ArrayList的get(int index)方法

get(int index)方法是返回指定下标处的元素的值。get函数会检查索引值是否合法（只检查是否大于size，而没有检查是否小于0）。如果所引致合法，则调用elementData(int index)方法获取值。在elementData(int index)方法中返回元素数组中指定下标的元素，并且对其进行了向下转型。

1.  
   public E get(int index) {
2.  
   // 检验索引是否合法
3.  
   rangeCheck(index);
4.  
    
5.  
   return elementData(index);
6.  
   }

 

1.  
   E elementData(int index) {
2.  
   return (E) elementData[index];
3.  
   }

十一、ArrayList的remove(int index)方法

remove(int index)方法的作用是删除指定下标的元素。在该方法的源码中，将指定下标后面一位到数组末尾的全部元素向前移动一个单位，并且把数组最后一个元素设置为null，这样方便之后将整个数组不再使用时，会被GC，可以作为小技巧。而需要移动的元素个数为：size-index-1。

1.  
   public E remove(int index) {
2.  
   // 检查索引是否合法
3.  
   rangeCheck(index);
4.  
    
5.  
   modCount++;
6.  
   E oldValue = elementData(index);
7.  
   // 需要移动的元素的个数
8.  
   int numMoved = size - index - 1;
9.  
   if (numMoved > 0)
10.  
    System.arraycopy(elementData, index+ 1, elementData, index,
11.  
    numMoved);
12.  
    // 赋值为空，有利于进行GC
13.  
    elementData[--size] = null;
14.  
    // 返回旧值
15.  
    return oldValue;
16.  
    }

 

十二、ArrayList的优缺点

• ArrayList的优点

1. ArrayList底层以数组实现，是一种随机访问模式，再加上它实现了RandomAccess接口，因此查找也就是get的时候非常快。
2. ArrayList在顺序添加一个元素的时候非常方便，只是往数组里面添加了一个元素而已。
3. 根据下标遍历元素，效率高。
4. 根据下标访问元素，效率高。
5. 可以自动扩容，默认为每次扩容为原来的1.5倍。

• ArrayList的缺点

1. 插入和删除元素的效率不高。
2. 根据元素下标查找元素需要遍历整个元素数组，效率不高。
3. 线程不安全。