JDK1.8 ArrayList 扩容详解

arraylist这个数据结构比较简单，总体来说，arraylist 底层结构是数组，他的很多方法都是从数组上面演变而来的，下面分析下arraylist的扩容机制，

每次在add()一个元素时，arraylist都需要对这个list的容量进行一个判断。如果容量够，直接添加，否则需要进行扩容。在1.8 arraylist这个类中，扩容调用的是grow()方法，通过grow()方法中调用的Arrays.copyof()方法进行对原数组的复制，在通过调用System.arraycopy()方法进行复制，达到扩容的目的

几个重要的初始化值

1. 存储数组元素的缓冲区

2. // non-private to simplify nested class access

3. transient Object[] elementData;

4. 默认空数组元素

5. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

6. 默认初始化容量

7. private static final int DEFAULT_CAPACITY = 10;

8. 数组的大小

9. private int size;

10. 记录被修改的次数

11. protected transient int modCount = 0;

12. 数组的最大值

13. private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8

几个重要的方法

一个空的构造方法

1. 默认数组的长度为10

2. public ArrayList() {

3. this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

4. }

添加元素的方法，

1. public boolean add(E e) {

2. 扩充长度，在原来的大小上面加1

3. // Increments modCount!!

4. ensureCapacityInternal(size + 1);

5. 添加元素

6. elementData[size++] = e;

7. return true;

8. }

确认内部容量

1. private void ensureCapacityInternal(int minCapacity) {

2. ensureExplicitCapacity(

3. calculateCapacity(elementData, minCapacity));

4. }

计算容量

1. private static int calculateCapacity (Object[] elementData, int minCapacity) {

2. 如果这个数组等于空，返回最大的容量，否则，还是原来的容量

3. if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

4. return Math.max(DEFAULT_CAPACITY, minCapacity);

5. }

6. return minCapacity;

7. }

确认扩展容量

1. private void ensureExplicitCapacity(int minCapacity) {

2. 修改次数加1

3. modCount++;

4. 如果容量不够，调用增加容量方法

5. // overflow-conscious code

6. if (minCapacity - elementData.length > 0)

7. grow(minCapacity);

8. }

扩展方法

1. private void grow(int minCapacity) {

2. // overflow-conscious code

3. 获取原来数组容量的长度

4. int oldCapacity = elementData.length;

5. 新增加的容量长度为原来容量的1.5倍

6. int newCapacity = oldCapacity + (oldCapacity >> 1);

7. 新容量比老容量小，那么新的容量就是老的容量

8. if (newCapacity - minCapacity < 0)

9. newCapacity = minCapacity;

10. 新创建的容量超过数组的最大值。抛出异常

11. if (newCapacity - MAX_ARRAY_SIZE > 0)

12. newCapacity = hugeCapacity(minCapacity);

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

14.  

15. 调用复制方法，在原来元素上增加容量，这就是传说中的可变集合。用新长度复制原数组。

16. elementData = Arrays.copyOf(elementData, newCapacity);

17. }

数组工具类中的复制方法

1. public static <T> T[] copyOf (T[] original, int newLength) {

2. return (T[]) copyOf(original, newLength, original.getClass());

3. }

具体的复制方法

1. public static <T,U> T[] copyOf(U[] original, int newLength,

2. Class<? extends T[]> newType) {

3. @SuppressWarnings("unchecked")

4. 获得者数组对象

5. T[] copy = ((Object)newType == (Object)Object[].class)

6. ? (T[]) new Object[newLength]

7. : (T[]) Array.newInstance(newType.getComponentType(), newLength);

8.  

9. 调用系统的方法增加数组容量

10. System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));

11. return copy;

12.