ArrayList源码解析-jdk1.8之add()和grow()方法

ArrayList源码解析-jdk1.8之add()和grow()方法

1. 首先点进new ArrayList<>()查看源码

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

发现elementData初始化等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA
而DEFAULTCAPACITY_EMPTY_ELEMENTDATA在源码中只是一个空数组
即数组容量还未定义

2. 点击add()方法

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

1. 发现 elementData[size++] = e 数组向后一位添加要添加的元素
2. 根据1知道ArrayList是有序可重复的
3. 前面知道数组容量还未确定，数组向后添加元素可能溢出，处理方法应该在ensureCapacityInternal里，点击查看

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

• 看不出什么来分别点击进入calculateCapacity方法和ensureExplicitCapacity里

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

• 发现如果elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA则比较默认容量和最小需要容量，返回最大的那个否则直接返回minCapacity

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

• 操作数加1
• 判断最小需要容量minCapacity 是否大于数组容量，大于则扩容

3. 点击grow()方法

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

• 定义oldCapacity为原来的数组大小
• 定义newCapacity 为原来的数组大小加上原来的数组的一半（原数组向右位移一位）
• 此时newCapacity 的容量仍然可能小于需要的最小容量，所以要进行判断
• 判断如果newCapacity <minCapacity，则将minCapacity赋值给newCapacity
• 还有一种情况minCapacity的大小大于MAX_ARRAY_SIZE（最大数组大小） 则进行相关处理这里就不在点击查看
• 最后一步扩容的数组的复制，查看copyOf

4. 点击copyOf()方法

    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

• ((Object)newType == (Object)Object[].class) 判断newType是否是Object数组，不是同类型按照传来的类型创建新数组
• 之后调用System.arrayCopy复制整个数组