图解Arraylist内存分配，图解arraylist内存

图解Arraylist内存分配，图解arraylist内存

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

2：源码解读ArrayList内部实现（数组结构）

构造ArrayList的时候，默认初始化容量为10，保存容器为 Object[] elementData。
向集合添加元素的时候，调用add方法，比如list.add("a");
add方法做的操作是：elementData[size++] = e; 然后元素就被存放进了elementData。
初始化容量为10，当我们存第十一个元素的时候，会怎么做呢？看ArrayList类的部分源码：
[java] view plaincopyprint?

1. public class ArrayList<E> extends AbstractList<E> implements List<E> {  
2.     private transient Object[] elementData;  
3.       
4.     public ArrayList(int initialCapacity) {  
5.         super();  
6.         if (initialCapacity < 0)  
7.             throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
8.         this.elementData = new Object[initialCapacity];  
9.     }  
10.     //Constructs an empty list with an initial capacity of ten.  
11.     public ArrayList() {  
12.         this(10);  
13.     }  
14.     public boolean add(E e) {  
15.         ensureCapacity(size + 1);  // 扩充长度  
16.         elementData[size++] = e; // 先赋值，后进行size++。所以是从[0]开始存。  
17.         return true;  
18.     }  
19.     public void ensureCapacity(int minCapacity) {  
20.         modCount++;  
21.         int oldCapacity = elementData.length; // 旧集合长度  
22.         if (minCapacity > oldCapacity) {  
23.             Object oldData[] = elementData; // 旧集合数据  
24.             int newCapacity = (oldCapacity * 3)/2 + 1; // 计算新长度，旧长度的1.5倍+1  
25.                 if (newCapacity < minCapacity)  
26.                     newCapacity = minCapacity;  
27.                 // minCapacity is usually close to size, so this is a win:  
28.                 elementData = Arrays.copyOf(elementData, newCapacity); // 这就是传说中的可变集合。用新长度复制原数组。  
29.         }  
30.     }  
31.     public E get(int index) {  
32.         RangeCheck(index);  
33.         return (E) elementData[index];  
34.     }  
35. }  

add方法中先调用ensureCapacity方法对原数组长度进行扩充，扩充方式为，通过Arrays类的copyOf方法对原数组进行拷贝，长度为原数组的1.5倍+1。
然后把扩容后的新数组实例对象地址赋值给elementData引用类型变量。扩容完毕。

3：扩容性能简单分析

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

1. public class Test {  
2.     public static void main(String[] args) {  
3.         increse(10, 1000);  
4.     }  
5.   
6.     private static int newCapacity; // 新容量  
7.     private static int count; // 扩容次数  
8.     private static int temp;  
9.       
10.     /** 
11.      * 计算扩容次数 
12.      * @param init 集合初始化大小 
13.      * @param elementDataSize 元素个数 
14.      */  
15.     public static void increse(int init, int elementDataSize) {  
16.         temp = init;  
17.         while (true) {  
18.             if (newCapacity >= elementDataSize)  
19.                 break;  
20.             increse(temp);  
21.         }  
22.     }  
23.     private static void increse(int init) {  
24.         newCapacity = (int) (init * 1.5 + 1); // 计算新容量  
25.         System.out.println("扩容第 [" + ++count + "] 次" + "\t"  
26.                                         + "新容量=" + newCapacity);  
27.         temp = newCapacity;  
28.     }  
29. }  

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

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