ArrayList源码

1：结构

 

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

• ArrayList继承于AbstractList,实现了List, RandomAccess, Cloneable,Serializable接口
• RandomAccess：是一个标志接口，表明ArrayList支持快速随机访问
• Cloneable：能被克隆，覆盖了函数clone()
• Serializable:支持序列忽而，能通过序列化去传输

2：基础属性

//默认初始容量 
private static final int DEFAULT_CAPACITY = 10;

//共享的空数组，用于初始化空实例 【有参构造】  空实例数组
private static final Object[] EMPTY_ELEMENTDATA = {};

//默认空的对象数据  【直接使用无参构造时使用】
//默认大小的空实例数组，在第一次调用ensureCapacityInternal时会初始化长度为10
//延迟初始化：初始化的时候还是空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA= {};

//ArrayList内部结构，Object[]类型的数组，存放元素的数组
transient Object[] elementData;

// 数组当前的元素数量,实际存储的元素个数
private int size;

问题(1)：EMPTY_ELEMENTDATA ，DEFAULTCAPACITY_EMPTY_ELEMENTDATA区别？

• EMPTY_ELEMENTDATA 用在有参构造器中，
• DEFAULTCAPACITY_EMPTY_ELEMENTDATA用在无参构造器中

问题（2）： transient Object[] elementData;

• transient: 在采用java默认的序列化机制的时候，被该关键字修饰的属性的不会被序列化。
• ArrayList类实现了java.io.Serializable接口，即采用了java默认的序列化机制
• ArrayList自己实现了序列化和反序列化的方法。

 

3：构造器

（1）默认的构造方法，指向一个空数组，大小为0

初始其实是空数组，当添加第一个元素的时候数组容量才变成10

/**
 * Constructs an empty list with an initial capacity of ten.
 * 构造一个初始容量为10的空列表
 */
public ArrayList() {
    // 空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA （用在无参构造器）
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

（2） 构造具有指定初始容量的空列表

步骤：

• 1：参数大于0，创建一个新数组，容量为入参
• 2：参数等于0，创建一个空数组。EMPTY_ELEMENTDATA
• 3： 其他，报错。

//传入参数initialCapacity的时候对其进行判断，
//大于0就创建新的数组，等于0 ，就指向空数组，小于0抛出异常。
public ArrayList(int initialCapacity) {
    // 参数大于0，创建一个新数组
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 空数组EMPTY_ELEMENTDATA（有参构造器中）
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

（3）构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序

public ArrayList(Collection<? extends E> c) {
    //将对象转换成数组
    elementData = c.toArray();
    //将转换后的object[]长度赋值给当前的ArrayList的size,并判断是不是0
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[]
        //进行类型转换  转换为Object对象 c.toArray() 并不一定能够放置Object对象
        if (elementData.getClass() != Object[].class)
        // 用来创建1个Object[]数组，这样数组中就可以存放任意对象了。   
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 转换成空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

问题：c.toArray might (incorrectly) not return Object[]

https://blog.csdn.net/aitangyong/article/details/30274749

https://blog.csdn.net/qq_27011769/article/details/102783244

 

4: boolean add(E e)

public boolean add(E e) {
    //首次添加元素的初始化与扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // ArrayList添加元素的实质就是相当于为数组赋值
    //将添加的值放到(size+1)位置上
    elementData[size++] = e;
    // 添加成功返回true 
    return true;
}

扩容步骤：

1： 计算最小扩容量：

如果是空数组，就返回默认容量=10；如果不是空数组，直接返回参数minCapacity

2：扩容

条件：minCapacity - elementData.length > 0

扩容具体步骤：

（1）计算旧长度:oldCapacity

（2）新长度newCapacity = oldCapacity * 1.5

（3）判断：newCapacity < 参数minCapacity ，取值newCapacity = 参数minCapacity

（4）判断：newCapacity大于整数最大值，就将newCapacity=最大值

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //传入的minCapacity=当前元素个数+1
    //首次调用 minCapacity=1 
    
    //如果使用不带参数的构造函数
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //DEFAULT_CAPACITY=10
        // 首次添加元素是， minCapacity=10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}


private void ensureCapacityInternal(int minCapacity) {
    //检查并确保容量
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    //档前elementData容量不符合要求的时候，进行扩容
    // 此时minCapacity有两种情况：
    // (1) minCapacity = 10
    //（2）minCapacity = size + 1
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
    // minCapacity=10,原来是一个空数组  oldCapacity=0  newCapacity =0
    // 扩容之后：newCapacity =10
    // minCapacity = size+1
    int oldCapacity = elementData.length;
    //扩容为原来的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //扩容之后还是不满足需要，容量大小就使用minCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //扩容之后超过了最大数组大小    
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //确保新的newCapacity最大只可以是Integer.MAX_VALUE
        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) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

 总结：

• 如果使用的是默认的构造器，elementData初始化大小=10
• 正常情况下，每次扩容后elementData的新大小=原来的1.5倍
• elementData最大值只能为Integer.MAX_VALUE

5: remove(int index):删除该列表中指定位置的元素

public E remove(int index) {
    rangeCheck(index);// 校验删除位置index

    modCount++;
    E oldValue = elementData(index);// 原来的数据

    int numMoved = size - index - 1;// 需要移动的元素个数
    if (numMoved > 0) // 删除的元素在末尾，就不需要移动元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 往前移之后，之前最后一个位置的元素已经前移，
    // 现在那个位置已经没有元素了，需要置为null
    // 设置数组长度为 size- 1
    elementData[--size] = null; // clear to let GC do its work

    return oldValue; // 删除之后返回原来位置的数据
}

关于list的删除：https://www.cnblogs.com/kintanx/p/10708491.html