java集合（三）ArrayList源码分析

arraylist最主要的就是扩容机制了，我们来看一看arraylist是怎样扩容的。

1. arrayList的成员变量

• 定义默认初始容量，为10
• 定义用于空实例的空数组实例
• 定义空数组实例，用于默认大小的空实例
• 定义了一个未被序列化的数组elementData，用来存储ArrayList对象列表
• 定义了ArrayList的size变量，size是存储的列表对象的数量，就是真正的存储的元素的数量
  capacity是底层数组的长度(length)（包含了没有被赋值的元素），size是存储的列表对象的数量。

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;

2.arrayList的构造方法

2.1 无参数构造（空数组）

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

2.2 用指定的初始容量构造一个空列表

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //属性指向新建长度为初始容量的临时数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+  initialCapacity);
        }
    }

2.3 构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回

public ArrayList(Collection<? extends E> c) {

        elementData = c.toArray();//用Collection初始化数组elementData
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

3. ArrayList扩容

arraylist扩容从add方法开始，以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为10

3.1 add方法

 public boolean add(E e) {
       //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;//添加对象时，自增size
        return true;
    }

3.2 ensureCapacityInternal方法

 private void ensureCapacityInternal(int minCapacity) {
        //先判断数组是否为空
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
           //如果数组为空，将DEFAULT_CAPACITY(为10)和minCapacity中较大的一个赋值给minCapacity
           //则minCapaciy至少为10
        }
        ensureExplicitCapacity(minCapacity);
        //执行ensureExplicitCapacity方法
    }

3.3 ensureExplicitCapacity方法

判断当前长度是否大于数组容量。

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//定义于ArrayList的父类AbstractList，用于存储结构修改次数
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
        //如果数组的长度(elementData.length)小于最小需要的容量(minCapacity)，就扩容
            grow(minCapacity);
    }

3.4 grow方法进行扩容

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//用来分配数组的size最大值
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //右移一位相当于原数除以2，位运算的计算方式更快
        //所以新容量扩大为原容量的1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //从minCapacity和这个newCapacity中取较大值作为扩容后的新数组长度（新容量）。
        //这主要是针对添加第1个元素。1.5倍oldCapacity为0，所以newCapacity为最小容量10
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity); 
         //如果新容量大于数组的最大size，进入hugeCapacity方法
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
        //最后，将原来数组的数据复制到新的数组中。
    
    }

4. 总结

(1) 添加第一个元素

• 当空列表add()第1个元素时，进入ensureCapacityInternal方法，原本minCapacity为1，在Math.max()方法比较后，minCapacity为10。

• 当要add第1个元素时，这时elementData.length（为0，因为此时还是空列表）是要比minCapacity（为10）小的，会进入grow(minCapacity)方法（minCapacity为10）。

• 当add第1个元素时，oldCapacity为0，经比较后第一个if判断成立，newCapacity = minCapacity(为10)。但是第二个if判断不会成立，即newCapacity 不比 MAX_ARRAY_SIZE大，则不会进入hugeCapacity方法。数组容量为10，add方法中return true,size增为1。

（2）添加第11个元素

• 直到添加第11个元素，minCapacity(为11)比elementData.length（为10）要大。进入grow方法进行扩容。

• 当add第11个元素进入grow方法时，newCapacity为15，比minCapacity（为11）大，第一个if判断不成立。新容量没有大于数组最大size，不会进入hugeCapacity方法。数组容量扩为15，add方法中return true,size增为11。