ArrayList源码分析

ArrayList源码分析

无参创建ArrayList集合

1. 外部创建集合对象 添加数据

public static void main(String[] args) {
        ArrayList list = new ArrayList();
    }

2. 进入ArrayList类的ArrayList()无参构造方法

创建了一个空的数组 elementData = {}

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

有参创建ArrayList集合

1. 外部创建集合对象 添加数据

public static void main(String[] args) {
        ArrayList list = new ArrayList(8);
    }

2. 进入ArrayList类有参构造方法

1. if (initialCapacity > 0)判断参数是否大于0 initialCapacity == 0) 判断参数是否等于0
   throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);如果是负数抛异常
2. this.elementData = new Object[initialCapacity];如果大于0执行这步
   创建一个长度为initialCapacity 叫elementData 数组

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);
        }
    }

给ArrayList集合添加数据

1. 调用集合对象add()方法

2. 进入Integer类 的valueOf(int i)方法

将传过来的数据进行装箱

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

3. 进入ArrayList类中的add()

方法先确认是否要扩容 再进行赋值
此时minCapacity的值为1传入ensureCapacityInternal()方法

4. 进入ArrayList类

ensureCapacityInternal(int minCapacity)方法
calculateCapacity(Object[] elementData, int minCapacity)方法
ensureExplicitCapacity(int minCapacity)方法
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
判断elementData 是否为空数组
return Math.max(DEFAULT_CAPACITY, minCapacity);//DEFAULT_CAPACITY=10 minCapacity = 1
如果elementData[] 数组为空，将elementData赋值给minCapacity传到ensureExplicitCapacity(int minCapacity)方法里

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//判断elementData 是否为空数组
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

5. 进入ArrayList类ensureExplicitCapacity(int minCapacity)方法

modCount 记录当前集合被修改次数
if (minCapacity - elementData.length > 0)判断当前容器最小容量是否比实际数组长度大
就要增加数组长度 调用grow(minCapacity)方法

 private void ensureExplicitCapacity(int minCapacity) {//minCapacity =  10
        modCount++;//modCount = 1

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

6. 进入ArrayList类grow(int minCapacity)方法

1. int oldCapacity = elementData.length;
   将数组长度赋值给oldCapacity字段
2. int newCapacity = oldCapacity + (oldCapacity >> 1);
   将oldCapacity 进行1.5倍扩容赋值给newCapacity
3. if (newCapacity - minCapacity < 0)
   如果扩容后的newCapacity 还比最小容量minCapacity 小就把最小容量minCapacity赋给newCapacity
4. if (newCapacity - MAX_ARRAY_SIZE > 0)
   判断新的长度是否比最大容量还要大
5. elementData = Arrays.copyOf(elementData, newCapacity);
   将newCapacity数组copy给elementData数组

private void grow(int minCapacity) {//minCapacity = 10
        // overflow-conscious code
        int oldCapacity = elementData.length;//oldCapacity =0
        int newCapacity = oldCapacity + (oldCapacity >> 1); //newCapacity = 0
        if (newCapacity - minCapacity < 0)//newCapacity = 0 minCapacity = 10 true
            newCapacity = minCapacity;//newCapacity = 10
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//elementData.length = 10
    }

7. 返回ArrayList类add(E e)方法

将传过来的参数传进elementData数组里
第一次添加元素结束开始添加第二条元素

public boolean add(E e) { //e = 1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;//elementData[0] = 1
        return true;
    }

8. 开始第二次扩容

当集合里存了10个元素后 再加又要开始扩容

9. 扩容步骤

1.先调用add(E e)-->ensureCapacityInternal(int minCapacity)--> calculateCapacity(Object[] elementData, int minCapacity)-->ensureExplicitCapacity(int minCapacity)
2. 进入grow(int minCapacity) 方法
3. 将elementData数组的长度赋值给oldCapacity
4. 将oldCapacity 扩容1.5倍赋值给newCapacity
5. if (newCapacity - minCapacity < 0)判断新扩容的长度是否比最小容量大
6. 将扩容后的长度赋给elementData数组
7. 一直返回ArrayList类的add()方法 将元素添加给新扩容的数组里面

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
}
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
}
private void grow(int minCapacity) {//minCapacity = 11
        // overflow-conscious code
        int oldCapacity = elementData.length;//oldCapacity = 10
        int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity  = 15
        if (newCapacity - minCapacity < 0) 
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
}

10. 此时list集合里面已经有了11个元素

11. 将元素全部添加进去

public static void main(String[] args) {
        ArrayList list = new ArrayList();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        for (int i = 11; i < 15; i++) {
            list.add(i);
        }
        list.add(100);
        list.add(150);
        list.add(null);
    }