ArrayList关键知识

1、成员变量

private static final int DEFAULT_CAPACITY = 10; // 默认容量，在未指定初始容量时，默认容量为10
private static final Object[] EMPTY_ELEMENTDATA = {}; // 除自动扩容场景外使用此空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 在扩容若是elementData指向此数组，elementData会初始化为容量为10的数组
transient Object[] elementData; // 数据存储数组
private int size; // 元素个数

2、关于初始化

ArrayList提供了三种构造器：

1. 无参构造器：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 无参构造器，默认初始容量为10，在第一次add时加载
}

2. 指定容量构造器：

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA; // 指定了初始容量为0时，指向空数组
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    }
}

3. 指定集合构造器

public ArrayList(Collection<? extends E> c) {
    elementData = c.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;
    }
}

3、关于扩容

1. 在调用add()方法是会调用ensureCapacityInternal(int minCapacity)告诉List我最少须要多少容量

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 若是elementData指向上文说的空数组，则将最少须要10个容量
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity); // 判断是否须要扩容
}

2.  ensureExplicitCapacit(int minCapacity)方法会判断到底需不须要扩容

private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 每次可能须要扩容的时候，必然会操做集合，因此在这里赞成进行modCount++

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity); // 若是须要的最小容量 大于 当前elementData.length，则扩容
}

 3. grow(int minCapacity)会进行扩容操做，默认按照原容量的1.5倍扩容

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length; // 老容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量默认等于 oldCapacity + oldCapacity / 2
    if (newCapacity - minCapacity < 0) // 若是计算的新容量 小于 须要的最小容量，则本次按照指定的minCapacity扩容
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0) // 若是新容量 大于 数组最大容量（Integer.Max_Value - 8）,进行大容量处理
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

4. 对于minCapacity超过MAX_ARRAY_SIZE的状况作一些操做 

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // 超过最大限制，抛出内存溢出错误 
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? // 不然返回最大数组长度（Integer.MAX_VALUE - 8）
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

5. 为何数组最大容量是 Integer.MAX_VALUE - 8？

// 由于有些VM会给数组加一些头部信息，若是指定再大的值可能会致使内存溢出

4、关于迭代

ArrayList内部实现Iterator接口，经过iterator()获取迭代器

1. 迭代器成员变量

int cursor;       // 下一个迭代的元素地址
int lastRet = -1; // 当前迭代的元素地址，调用next()方法时会等于cursor
int expectedModCount = modCount; // 用于判断是否有并发操做问题

2. 使用hasNext()方法，判断是否还有未迭代的元素

public boolean hasNext() {
    return cursor != size;
}

3. 使用next()方法获取下一个元素

public E next() {
    checkForComodification(); // 检查是否有并发操做问题
    int i = cursor;  // 获取当前元素下标
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;  // 指针指向下一个元素
    return (E) elementData[lastRet = i];  // 获取当前元素
}

4. 若是须要删除当前元素，使用remove()方法删除，保证迭代器正常使用

public void remove() {
    if (lastRet < 0) // lastRet < 0说明当前没有元素
        throw new IllegalStateException();
    checkForComodification();  // 检查并发操做问题

    try {
        ArrayList.this.remove(lastRet);  // 按照下标删除
        cursor = lastRet;  // cursor - 1
        lastRet = -1;  // 当前元素指向 -1
        expectedModCount = modCount; // 保证操做正常
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

5. checkForComodification()检查是否有并发操做

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}