ArrayList的底层原理

ArrayList的数据结构

 ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对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的主要成员变量

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。
 

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 = {};
    // 缺省空对象数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 元素数组
    transient Object[] elementData;
    // 实际元素大小，默认为0
    private int size;
    // 最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}

ArrayList的add()方法

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

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

ArrayList的扩容机制

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

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，则指定新容量。最后将旧数组拷贝到扩容后的新数组中。
 

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

对数组进行判断，判断该数组是否为空，，这是一个空的数组，在前面声明过，如果现存的数组等于空的，我们就返回一个数值，，第一个变量是常量10，第二个是我们前面传入进来的，比较它俩的大小，返回大的数值。

如果不为空的话，我么直接返回前面方法传入的数值。进入ensureExplicitCapacity()方法。

 

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

如果minCapacity比当前元素数组的长度的大小大的时候需要扩容 

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

首先进行判断，如果新长度减去数组原先的长度大于0，我们则调用grow方法，并将新长度传入进去。

这里就是ArrayList底层数组扩容的核心代码。'

int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量为旧容量的1.5倍

新长度是旧长度加上旧长度的0.5，所以ArrayList底层数组每次扩容的大小都是1.5倍。

第一个if，如果新创建的长度小于传入的数组长度，那么就更新newCapacity的值为minCapacity。

第二个if，如果新数组长度减去最大的数组长度大于0的话，会进入hugeCapacity再次进行判断，返回Integer的最大长度，或者Integer的最大长度-8的长度。
 

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

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

public E set(int index, E element) {
    // 检验索引是否合法
    rangeCheck(index);
    // 旧值
    E oldValue = elementData(index);
    // 赋新值
    elementData[index] = element;
    // 返回旧值
    return oldValue;
}

ArrayList的indexOf(Object o)方法

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

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

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

ArrayList的get(int index)方法

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

public E get(int index) {
    // 检验索引是否合法
    rangeCheck(index);
 
    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

ArrayList的remove(int index)方法

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

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

ArrayList的优缺点


ArrayList的优点


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


ArrayList的缺点


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