跟我一块儿读源码之ArrayList

ArrayList

带着问题去寻找答案：

public static void main(String[] args) {
        // 你们都知道ArrayList底层是数组,那ArrayList初始化的数组长度是多少? 
        // 何时初始化的？
        // 咱们都知道数组长度是固定的,ArrayList底层数组是何时扩容的？
    	// 扩容的规律又是什么样的呢?
        ArrayList<String> list = new ArrayList<String>();

        list.add("String");
        list.add("integer");
        list.add("integer");

        // ArrayList调用清空方法,数组长度会变化吗?
        list.clear();

        list.add("1");
    }

全局变量

默认容量

/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;

空的对象数组

/**
 * Shared empty array instance used for empty instances.
 */
 private static final Object[] EMPTY_ELEMENTDATA = {};

默认的空数组

/**
*  无参构造函数建立的数组
   new ArrayList()
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

存储数据的数组，不能被序列化

transient Object[] elementData; // non-private to simplify nested class access

元素数量

/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;

构造方法

无参构造

public ArrayList() {
    // 建立一个空的数组对象
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

有参构造

/**
*  
* @param initialCapacity 初始化容量,不能小于0
*/
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 若是初始化容量大于0,建立一个该大小的数组
    	this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 若是初始化容量等于0,建立一个空的数组对象
    	this.elementData = EMPTY_ELEMENTDATA;
    } else {
    	throw new IllegalArgumentException("Illegal Capacity: "+
    	initialCapacity);
    }
}

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;
    }
}

方法

一、add()

public boolean add(E e) {
    // 确保初始化容量足够,进行扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 判断当前数组是否为默认的空数组对象
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    	// 是,判断默认容量是否大于minCapacity,大于取默认容量(10)
   		minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 扩容
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 记录修改次数
	modCount++;

    // 若是minCapacity 是否大于当前数组的长度
    if (minCapacity - elementData.length > 0){
        // 扩容
    	grow(minCapacity);
    }
}

// ArrayList动态扩容的核心方法
private void grow(int minCapacity) {
    // 获取当前数组的容量
    int oldCapacity = elementData.length;
    // 扩容至原来的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 判断下新数组容量够不够，不够的话，把min Capacity赋值给newCapacity
    if (newCapacity - minCapacity < 0){
        newCapacity = minCapacity;
    }
    // 判断新数组容量是否大于数组最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0){
        newCapacity = hugeCapacity(minCapacity);
    }
    // copy一个新的数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// huge:巨大的
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

参考:https://blog.csdn.net/ljcITworld/article/details/52041836