ArrayList1.8 源码

1.private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8？

为什么要-8 主要是考虑到不同的JVM,有的VM会在加入一些数据头,当扩容后的容量大于MAX_ARRAY_SIZE,

我们会去比较最小需要容量和MAX_ARRAY_SIZE做比较,如果比他大, 只能取Integer.MAX_VALUE,否则是

Integer.MAX_VALUE -8。

2. 1.6、1.7、1.8区别

1、默认构造方法，ArrayList()

关于默认构造方法，在别的地方看见过这种话：无参构造方法（默认构造方法）构造的ArrayList的底层

数组elementData大小（容量）默认为10。这里告诉你，这不一定是对的。这句话在1.6版本中是对的，

从1.7开始这句话就有问题了。下面我贴出了三个版本的代码：

jdk1.6的，初始化成10个容量。

// jdk1.6的  /** Constructs an empty list with an initial capacity of ten. */      public ArrayList() {      this(10);  }  

jdk1.7的，相对1.6版本，引入了一个新的常量EMPTY_ELEMENTDATA，它是一个空数组，因此容量为0。

// jdk1.7的  /** Shared empty array instance used for empty instances. */  private static final Object[] EMPTY_ELEMENTDATA = {};    ...    /** Constructs an empty list with an initial capacity of ten. */  public ArrayList() {      super();      this.elementData = EMPTY_ELEMENTDATA;  } 

jdk1.8的，相对1.7版本，又引入了一个新的常量DEFAULTCAPACITY_EMPTY_ELEMENTDATA ，它也是一个空数组，因此容量也为0。

/** Shared empty array instance used for empty instances. */  private static final Object[] EMPTY_ELEMENTDATA = {};    /**  * Shared empty array instance used for default sized empty instances. We  * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when  * first element is added.  */  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    ...    /** Constructs an empty list with an initial capacity of ten. */  public ArrayList() {      this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;  }  

对比下可以看出：jdk1.6的无参构造方法（默认构造方法）构造的ArrayList的底层数组elementData大小（容量）

默认为10；从1.7开始，无参构造方法构造的ArrayList的底层数组elementData大小默认为0。

java集合类在jdk1.7版本基本上都有一种改动：懒初始化。懒初始化指的是默认构造方法构造的集合类，占据尽可

能少的内存空间（对于ArrayList来说，使用空数组来占据尽量少的空间，不使用null是为了避免null判断），在第

一次进行包含有添加语义的操作时，才进行真正的初始化工作。

1.7开始的ArrayList，默认构造方法构造的实例，底层数组是空数组，容量为0，在进行第一次add/addAll等操作

时才会真正给底层数组赋非empty的值。如果add/addAll添加的元素小于10，则把elementData数组扩容为10个

元素大小，否则使用刚好合适的大小（例如，第一次addAll添加6个，那么扩容为10个，第一次添加大于10个的，

比如24个，扩容为24个，刚好合适）；1.8版本，默认构造的实例这个行为没有改变，只是用的数组名字变了。

2、带初始容量的构造方法，public ArrayList(int initialCapacity)

1. // 1.6  
2. public ArrayList(int initialCapacity) {  
3.     super();  
4.     if (initialCapacity < 0)  
5.         throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
6.     this.elementData = new Object[initialCapacity];  
7. }  
8.   
9. // 1.7 跟1.6的一样  
10. public ArrayList(int initialCapacity) {  
11.     super();  
12.     if (initialCapacity < 0)  
13.         throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
14.     this.elementData = new Object[initialCapacity];  
15. }  
16.   
17. // 1.8  
18. public ArrayList(int initialCapacity) {  
19.     if (initialCapacity > 0) {  
20.         this.elementData = new Object[initialCapacity];  
21.     } else if (initialCapacity == 0) {  
22.         this.elementData = EMPTY_ELEMENTDATA; // 重用空数组，一个小小的优化  
23.     } else {  
24.         throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
25.     }  
26. }  

678三个版本的这个构造方法的实际行为基本一致：如果initialCapacity >= 0，把底层数组elementData赋值

为一个大小为initialCapacity的数组，数组的所有元素都是默认值null。1.8稍微进行了一点优化，也是赋值为空

数组，但是重用了常量对象

3、Collection拷贝构造方法，public ArrayList(Collection<? extends E> c)

1. // jdk 1.6  
2. public ArrayList(Collection<? extends E> c) {  
3.     elementData = c.toArray();  
4.     size = elementData.length;  
5.     // c.toArray might (incorrectly) not return Object[] (see 6260652)  
6.     if (elementData.getClass() != Object[].class)  
7.         elementData = Arrays.copyOf(elementData, size, Object[].class);  
8. }  
9.   
10. // jdk 1.7  
11. public ArrayList(Collection<? extends E> c) {  
12.     elementData = c.toArray();  
13.     size = elementData.length;  
14.     // c.toArray might (incorrectly) not return Object[] (see 6260652)  
15.     if (elementData.getClass() != Object[].class)  
16.         elementData = Arrays.copyOf(elementData, size, Object[].class);  
17. }  
18.   
19. // jdk 1.8  
20. public ArrayList(Collection<? extends E> c) {  
21.     elementData = c.toArray();  
22.     if ((size = elementData.length) != 0) {  
23.         // c.toArray might (incorrectly) not return Object[] (see 6260652)  
24.         if (elementData.getClass() != Object[].class)  
25.             elementData = Arrays.copyOf(elementData, size, Object[].class);  
26.     } else {  
27.         // replace with empty array.  
28.         this.elementData = EMPTY_ELEMENTDATA;  
29.     }  
30. }  

此构造方法会有和Array.copyOf/System.arraycopy一样的问题，那就是它只是新建一个elementData数组，数组的

内容对应相等，但是不拷贝实际的元素，实际的元素占据的内存空间还是共享的。

三、确保容量方法（扩容方法）：ensureCapacity/ensureCapacityInternal

提前声明下：这两个方法只是确保容量，不一定会扩容，但是为了好理解，下面的文字中所说的"扩容"指的就是这两个方法。

因为原生的数组的容量不能改变，要改变数组的容量，只能是新建一个数组，并把原来数组的内容复制到新数组对应位置

上去。数组拷贝使用的是Arrays.copyOf，底层用的是System.arraycopy，比循环赋值效率高。扩容示意图如下。

扩容方法四个位置用到：两个add方法，两个addAll方法，一个反序列化方法，还有就是手动扩容方法

ensureCapacity（称之为手动，是因为此方法是public的，可以外部手动调用）。在1.6版本是只有这个手动的方法，

内部自动操作也是调用这个方法，1.7开始进行了区分，并且进一步改进了扩容操作。

下面的是jdk1.8的代码，1.7的和1.8的基本相同，唯一的一点区别就是1.8用两个空数组，导致这里的空数组的名字

不一样，两个版本的代码可以看作是一样的。

[java] view plain copy

1. // 手动扩容方法（可以外部调用，不过大多数情况都是List<?> = new ArrayList<>()，这样是调用不到这个方法的）  
2. // 这个方法只是简单区别下list是不是通过 new ArrayList() 来创建的，这一点前面说了  
3. // 如果是，则尝试最小扩容10个，不是则尝试扩容指定个，具体也是通过内部扩容方法完成容量确保  
4. public void ensureCapacity(int minCapacity) {  
5.     int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)  
6.         // any size if not default element table  
7.         ? 0  
8.         // larger than default for default empty table. It's already  
9.         // supposed to be at default size.  
10.         : DEFAULT_CAPACITY;  
11.   
12.     if (minCapacity > minExpand) {  
13.         ensureExplicitCapacity(minCapacity);  
14.     }  
15. }  
16.   
17. // 下面是内部扩容相关的几个方法的代码  
18. private void ensureCapacityInternal(int minCapacity) {  
19.     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  
20.         minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);  
21.     }  
22.   
23.     ensureExplicitCapacity(minCapacity);  
24. }  
25.   
26. private void ensureExplicitCapacity(int minCapacity) {  
27.     modCount++;  
28.   
29.     // overflow-conscious code 考虑int型溢出  
30.     if (minCapacity - elementData.length > 0)  
31.         grow(minCapacity);  
32. }  
33.   
34. private void grow(int minCapacity) {  
35.     // overflow-conscious code 考虑int型溢出  
36.     int oldCapacity = elementData.length;  
37.     int newCapacity = oldCapacity + (oldCapacity >> 1);  
38.     if (newCapacity - minCapacity < 0)  
39.         newCapacity = minCapacity;  
40.     if (newCapacity - MAX_ARRAY_SIZE > 0)  
41.         newCapacity = hugeCapacity(minCapacity);  
42.     // minCapacity is usually close to size, so this is a win:  
43.     elementData = Arrays.copyOf(elementData, newCapacity);  
44. }  
45.   
46. private static int hugeCapacity(int minCapacity) {  
47.     if (minCapacity < 0) // overflow int型溢出，直接报错  
48.         throw new OutOfMemoryError();  
49.     return (minCapacity > MAX_ARRAY_SIZE) ?  
50.         Integer.MAX_VALUE :  
51.         MAX_ARRAY_SIZE;  
52. }  

下面这是1.6的相关代码，可以对比看下：

[java] view plain copy

1. public void ensureCapacity(int minCapacity) {  
2.     modCount++;  
3.     int oldCapacity = elementData.length;  
4.     if (minCapacity > oldCapacity) {  
5.         Object oldData[] = elementData;  
6.         int newCapacity = (oldCapacity * 3)/2 + 1;  
7.         if (newCapacity < minCapacity)  
8.             newCapacity = minCapacity;  
9.         // minCapacity is usually close to size, so this is a win:  
10.         elementData = Arrays.copyOf(elementData, newCapacity);  
11.     }  
12. }  

区别就是：1.6的方法只是简单进行了逻辑上的操作，没有过多考虑int型溢出的问题，从1.7（上面贴的是1.8的）

开始对这个进行了完善。

1、没考虑入参minCapacity可能因为int溢出变为负数。这个方法可以外部手动调用，手动扩容传入负数这个肯定

是应该拦截掉的。但是自动扩容会因为int溢出产生负数，碰到这种情况时应该特殊处理，而不是什么都不做，等着

后面抛出一个ArrayIndexOutOfBoundsException。

2、就是这句代码不太好，过早溢出

     int newCapacity = (oldCapacity * 3)/2 + 1;

虽然上面这行代码和1.7开始的oldCapacity + (oldCapacity >> 1) 看上去一样，都是相当于1.5倍，但实际上是有

区别的。两个区别，第一个小区别是jdk1.6的那种乘除运算的数学结果比后面一个大1比如oldCapacity=10，1.6的

算法得到16，1.7开始的算法得到15，这个影响不大；第二个区别就是两者在数字比较大是运算结果不一样，比如

oldCapacity=10^9，这个数和Integer.MAX_VALUE位数一样，用1.6的算法得到的会是错误的-647483647，用

1.7的则是正确的1500000000，这时候明明可以1.5倍扩容，但是jdk1.6却用的是按需扩容。

所以1.7版本对上面两个问题做了修改。

1、从1.7开始将内部扩容和外部可以调用的扩容方法分开了，通过源码（上面贴的是1.8的代码，可以看出是一样的）

可以看出：外部调用的手动扩容方法ensureCapacity要多一个判断条件 minCapacity > minExpand，这个判断条件

拦截掉负数的minCapacity，这样调用内部扩容ensureCapacityInternal方法时，minCapacity一定是正数；内部扩

容方法直接就用minCapacity - elementData.length > 0判断，此条件可以检测出int型溢出，碰到溢出最后会抛出

一个OOM错误。jdk1.7用OOM，这比jdk1.6用ArrayIndexOutOfBoundsException更好，因为此时数组大小超出

了虚拟机对数组的限制，虚拟机无法处理这种情况了，抛出一个ERROR是合理的。

2、使用这行代码

     newCapacity = oldCapacity + (oldCapacity >> 1);

这行不仅仅是是用位运算加快执行速度，上面说了，这种做法才是对的，是真正的1.5倍。不仅仅因为那一个大小的

差别，更重要的是避免过早出现int溢出的情况，保证了内部自动扩容会尽量按规定的策略执行。同时整个扩容处理

流程中多增加了几处if判断，对各种情况处理更加完善。

还有一个问题就是，MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8。这个是1.7开始才有的

独有的两个方法

public void ensureCapacity(int minCapacity)：可以外部调用的手动扩容方法，在要添加大量元素之前，预估

下容量，调用这个方法手动扩容，避免频繁自动扩容降低性能。

public void trimToSize()：节省空间，使得elementData刚好容纳下所有元素。