1：集合内存分配以及初始化过程图解

2：源码解读ArrayList内部实现(数组结构)

构造ArrayList的时候，默认初始化容量为10，保存容器为 Object[] elementData。

向集合添加元素的时候，调用add方法，比如list.add("a");

add方法做的操作是：elementData[size++] = e; 然后元素就被存放进了elementData。

初始化容量为10，当我们存第十一个元素的时候，会怎么做呢？看ArrayList类的部分源码：

public class ArrayList extends AbstractList implements List {

private transient Object[] elementData;

public ArrayList(int initialCapacity) {

super();

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);

this.elementData = new Object[initialCapacity];

}

//Constructs an empty list with an initial capacity of ten.

public ArrayList() {

this(10);

}

public boolean add(E e) {

ensureCapacity(size + 1); // 扩充长度

elementData[size++] = e; // 先赋值，后进行size++。所以是从[0]开始存。

return true;

}

public void ensureCapacity(int minCapacity) {

modCount++;

int oldCapacity = elementData.length; // 旧集合长度

if (minCapacity > oldCapacity) {

Object oldData[] = elementData; // 旧集合数据

int newCapacity = (oldCapacity * 3)/2 + 1; // 计算新长度，旧长度的1.5倍+1

if (newCapacity < minCapacity)

newCapacity = minCapacity;

// minCapacity is usually close to size, so this is a win:

elementData = Arrays.copyOf(elementData, newCapacity); // 这就是传说中的可变集合。用新长度复制原数组。

}

}

public E get(int index) {

RangeCheck(index);

return (E) elementData[index];

}

}add方法中先调用ensureCapacity方法对原数组长度进行扩充，扩充方式为，通过Arrays类的copyOf方法对原数组进行拷贝，长度为原数组的1.5倍+1。

然后把扩容后的新数组实例对象地址赋值给elementData引用类型变量。扩容完毕。

3：扩容性能简单分析

可以看到，扩容长度是旧长度的1.5倍+1，可以通过下面的程序计算出扩容次数：

public class Test {

public static void main(String[] args) {

increse(10, 1000);

}

private static int newCapacity; // 新容量

private static int count; // 扩容次数

private static int temp;

/**

* 计算扩容次数

* @param init 集合初始化大小

* @param elementDataSize 元素个数

*/

public static void increse(int init, int elementDataSize) {

temp = init;

while (true) {

if (newCapacity >= elementDataSize)

break;

increse(temp);

}

}

private static void increse(int init) {

newCapacity = (int) (init * 1.5 + 1); // 计算新容量

System.out.println("扩容第 [" + ++count + "] 次" + "\t"

+ "新容量=" + newCapacity);

temp = newCapacity;

}

}经测试，如果要存100万数据，需要扩容28次，数据量越大，扩容次数越多，每一次的扩容代表着创建新数组对象，复制原有数据。

如果数据很大，那么有必要为集合初始化一个默认大小，防止多次扩容，但如果数据增长很慢，那么就会浪费内存了，具体怎么做，还是要看实际应用场景。这里只做初步分析。

原创文章，转载请注明出处：http://blog.csdn.net/thinking_in_android