ArrayList自动扩容解析

1. 探索ArrayList自动改变size真相  
2. ArrayList的列表对象实质上是存储在一个引用型数组里的，有人认为该数组有“自动增长机制”可以自动改变size大小。正式地说，该数组是无法改变  
3. 大小的，实际上它只是改变了该引用型数组的指向而已。下面，让我们来看看java是怎样实现ArrayList类的。  
4. 一、ArrayList类的实质  
5.      ArrayList底层采用Object类型的数组实现，当使用不带参数的构造方法生成ArrayList对象时，  
6. 实际上会在底层生成一个长度为10的Object类型数组。  
7.     首先，ArrayList定义了一个私有的未被序列化的数组elementData，用来存储ArrayList的对象列表（注意只定义未初始）：  
8. 　　private transient Object[] elementData;  
9.       
10.     其次，以指定初始容量（Capacity）或把指定的Collection转换为引用型数组后实例化elementData数组；如果没有指定，则预置初始容量为10进行  
11. 实例化。把私有数组预先实例化，然后通过copyOf方法覆盖原数组，是实现自动改变ArrayList的大小(size)的关键。有人说ArrayList是复杂的数组，我  
12. 认为不如说ArrayList是关于数组的系统的方法组合。  
13. 　　ArrayList的构造方法源码如下：  
14.     // 用指定的初始容量构造一个空列表。  
15.     public ArrayList(int initialCapacity) {  
16.         super();  
17.         if (initialCapacity < 0)  
18.             throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);  
19.         this.elementData = new Object[initialCapacity];//属性指向新建长度为初始容量的临时数组  
20.     }  
21.     // 使用初始容量10构造一个空列表  
22.     public ArrayList() {  
23.         this(10);  
24.     }  
25.     / *构造包含利用collection的迭代器按顺序返回的指定collection元素的列表  
26.      * @param c 集合，它的元素被用来放入列表t  
27.      * @throws NullPointerException 如果指定集合为 null  
28.      */  
29.     public ArrayList(Collection<? extends E> c) {  
30.         elementData = c.toArray();//用Collection初始化数组elementData  
31.         size = elementData.length;  
32.         if (elementData.getClass() != Object[].class)  
33.             elementData = Arrays.copyOf(elementData, size, Object[].class);  
34.     }  
35. 二、ArrayList实现自动改变size机制  
36.    为了实现这一机制，java引进了Capacity和size概念，以区别数组的length。为了保证用户增加新的列表对象，java设置了最小容量（minCapacity）  
37. ，通常情况上，它大于列表对象的数目，所以Capactiy虽然就是底层数组的长度（length），但是对于最终用户来讲，它是无意义的。而size存储着列表  
38. 对象的数量，才是最终用户所需要的。为了防止用户错误修改，这一属性被设置为privae的，不过可以通过size()获取。  
39.    下面，对ArrayList的初始以及其列表对象的增加和删除等三种情况下的size自动改变机制进行分析。  
40.    1、初始Capacity和size值。  
41.    从上面给出的ArrayList构造方法源码中，我们不难看出Capacity初始值（initialCapacity）可以由用户直接指定或由用户指定的Collection集合存  
42. 储的对象数目确定，如果没有指定，系统默认为10。而size的被声明为int型变量，默认为0，当用户指定Collection创建ArrayList时，size值等于  
43. initialCapacity。  
44.    
45.    2、add()方法  
46.     该方法的源码如下：  
47.     public boolean add(E e) {  
48.         ensureCapacityInternal(size + 1);  
49.         elementData[size++] = e;//添加对象时，自增size  
50.         return true;  
51.     }  
52.     方法中调用的ensureCapacityInternal主要用来调整容量，修改elementData数组的指向。其中涉及到3个方法的调用，其核心在于grow方法：  
53.       
54.     private void ensureCapacityInternal(int minCapacity) {  
55.         modCount++;//定义于ArrayList的父类AbstractList，用于存储结构修改次数  
56.         // overflow-conscious code  
57.         if (minCapacity - elementData.length > 0)  
58.             grow(minCapacity);  
59.     }    
60.     private void grow(int minCapacity) {  
61.         // overflow-conscious code  
62.         int oldCapacity = elementData.length;  
63.         int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量扩大到原容量的1.5倍，右移一位相关于原数值除以2。  
64.         if (newCapacity - minCapacity < 0)  
65.             newCapacity = minCapacity;  
66.         if (newCapacity - MAX_ARRAY_SIZE > 0)  
67.             newCapacity = hugeCapacity(minCapacity);  
68.         // minCapacity is usually close to size, so this is a win:  
69.         elementData = Arrays.copyOf(elementData, newCapacity);  
70.     }  
71.     private static int hugeCapacity(int minCapacity) {  
72.         if (minCapacity < 0) // overflow  
73.             throw new OutOfMemoryError();  
74.         return (minCapacity > MAX_ARRAY_SIZE) ?  
75.             Integer.MAX_VALUE :  
76.             MAX_ARRAY_SIZE;//MAX_ARRAY_SIZE和Integer.MAX_VALUE为常量，详细请参阅下面的注解  
77.     }  
78.      
79.    通过以上代码，我们可知java自动增加ArrayList大小的思路是：向ArrayList添加对象时，原对象数目加1如果大于原底层数组长度，则以适当长度新  
80. 建一个原数组的拷贝，并修改原数组，指向这个新建数组。原数组自动抛弃（java垃圾回收机制会自动回收）。size则在向数组添加对象，自增1。  
81.    
82.    注解：  
83.     //定义于该类的常量，用来分配数组的size最大值。一些 VMs在数组里保留字头，试图分配更大数组时可能导致OutOfMemoryError:被请求数组的  
84. size超出VM界限。  
85.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  
86.    //在java.lang.Integer类中常量MIN_VALUE、MAX_VALUE如下：  
87.    public static final int   MIN_VALUE = 0x80000000;//整型取值区间下界：－2147483648  
88.    public static final int   MAX_VALUE = 0x7fffffff;//整型取值区间上界：2147483647  
89. 　　//在java.util.AbstractList中modCount定义如下：  
90. 　　protected transient int modCount = 0;  
91.     3、remove()方法  
92.     该重构方法其一源码如下（其它的就不累述了）：  
93.     public E remove(int index) {  
94.         rangeCheck(index);  
95.         modCount++;  
96.         E oldValue = elementData(index);  
97.         int numMoved = size - index - 1;  
98.         if (numMoved > 0)  
99.             System.arraycopy(elementData, index+1, elementData, index,  
100.                              numMoved);//将后面的列表对象前移  
101.         elementData[--size] = null; // 数组前移一位，size自减，空出来的位置置null，具体的对象的销毁由Junk收集器负责  
102.         return oldValue;  
103.     }  
104.     private void rangeCheck(int index) {//边界检查  
105.         if (index < 0 || index >= this.size)  
106.            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));  
107.     }  
108.     E elementData(int index) {//获取指定index所在位置的对象  
109.         return (E) elementData[index];  
110.     }  
111.    
112.     通过remove()源码的学习，我们不难看出，其改变ArrayList大小的核心与add()方法相似，都是同数组拷贝。  
113.     另外，如果确有必要，用户也可以指定ArrayList实例的容量，可以有效的降低时间成本。它是通过调用ensureCapacityInternal来实现的，源代码  
114. 如下：  
115.     public void ensureCapacity(int minCapacity) {  
116.         if (minCapacity > 0)  
117.             ensureCapacityInternal(minCapacity);  
118.     }  
119.     因为size为private的，java给出方法来访问它：  
120.     public int size() {  
121.          checkForComodification();  
122.          return this.size;  
123.     }