ArrayList底层源码

ArrayList底层源码

结论

1. ArrayList中维护了一个Object类型的数组elementData.(transient Object[] elementData;)
2. 当创建ArrayList对象的时候，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如果需要再次扩容，则扩容elementData为1.5倍。
3. 如果使用的是指定大小的构造器，则初始化elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍。

transient 关键词表示瞬间、短暂的，属性或者成员被transient 修饰表示该属性不会被序列化

ArrayList的数据结构

ArrayList底层数据结构是一个类型为Object的数组

继承体系

基于数组实现，支持动态扩容，方便元素插入和删除操作，支持随机访问。
ArrayList继承于AbstractList，实现了Cloneable、List、RandomAccess、Serializable这些接口。

• 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
• 实现了Cloneable接口，即覆盖了函数clone()，所以它能被克隆。
• 实现了RandmoAccess接口，实现了随机访问的效果。
• 实现了Serializable接口，这意味着ArrayList支持序列化

成员变量

    //默认容量大小为10
    private static final int DEFAULT_CAPACITY = 10;
    //空数组，传入的容量为 0 的时候使用  new ArrayList(0)
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 空数组，创建后容量为0
    // 添加一个元素时会将数组大小初始化为 10
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //底层采用数组实现，存放实际数据
    //标识transient 表示不可序列化
    transient Object[] elementData; 
    //集合内元素的个数，并非容量大小
    private int size;
    // 最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

构造方法

1、带int类型的构造方法

//传入初始容量，如果容量大于0就会初始化elementData对应大小的数组
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //数组立即创建，并不会懒创建
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //如果传入的容量为0，则使用默认的空数组EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //容量小于0抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

• 如果传入的参数大于0，则会新建一个初始容量大小的数组
• 如果传入的参数等于0，则使用默认的空数组
• 如果传入的参数小于0，则抛出异常

2、无参构造方法

//不会传入默认初始容量，空参构造器，则使用默认的DEFAULTCAPACITY_EMPTY_ELEMENTDATA数组赋值给elementData
    //在添加第一个元素的时候才会扩容到默认大小10
    public ArrayList() {
        // 创建了一个空的数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

3、Collection<? extends E>型构造方法

public ArrayList(Collection<? extends E> c) {
	// 将参数中的集合转换为数组，赋值给 elementData 
    elementData = c.toArray();
    // 如果数组的大小不等于 0
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        // 如果c.toArray()返回的数组类型不是Object[]类型的
        // 则利用Arrays.copyOf()创建一个大小为size的、类型为Object[]的数组, 并将elementData中的元素复制到新的数组中
        // 最后让elementData 指向新的数组
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else { // 否则设置元素数组为空数组
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

1. 将参数中的集合转化为数组赋给elementData；
2. 参数集合是否是空。通过比较size与第一步中的数组长度的大小。
3. 如果参数集合为空，则设置元素数组为空，即将EMPTY_ELEMENTDATA赋给elementData；
4. 如果参数集合不为空，接下来判断是否成功将参数集合转化为Object类型的数组，如果转化成Object类型的数组成功，则将数组进行复制，转化为Object类型的数组。

扩容机制

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、在add()方法中调用ensureCapacityInternal方法，传入当前集合元素个数，表示添加元素所需要的最小容量。

 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 判断容量是否足够，传入的是集合内元素个数
        elementData[size++] = e;
        return true;
    }

2、在ensureCapacityInternal方法内首先调用calculateCapacity方法来判断是否为空数组，为空首先初始容量为10

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));  //确定是否扩容
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {   //判断是不是空数组
            return Math.max(DEFAULT_CAPACITY, minCapacity); //是空数组，赋值最小容量10
        }
        return minCapacity;
    }

3、在ensureCapacityInternal()方法里面调用ensureExplicitCapacity(int minCapacity)方法，用来判段集合在添加元素的时候是否需要对当前的数组进行扩容。

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;   // 记录该集合被修改的次数，防止多线程操作出现异常
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)  // 如果elementData容量不够，需要扩容
            grow(minCapacity); //扩容
    }

4、在ensureExplicitCapacity() 方法里面调用grow(int minCapacity)方法，进行扩容。最后调用 Arrays.copyOf()方法，用来复制原数组，将 elementData 赋值为得到的新数组。

private void grow(int minCapacity) {
    // overflow-conscious code
    // 原本的容量
    int oldCapacity = elementData.length;
    // 新的容量是原本容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果新容量小于指定的容量
    //如果是第一次特殊，新容量大小为0，则需要先把最小容量给新的容量大小
    if (newCapacity - minCapacity < 0)
    	// 将指定的容量赋值给新容量
        newCapacity = minCapacity;
    // 如果新容量大于指定的容量
    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);
}

/**
 *hugeCapacity()方法，用于处理minCapacity超出MAX_ARRAY_SIZE的情况
 */
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}