Java之ArrayList源码简单分析

前言

ArrayList 源码简单分析，更深刻的理解ArrayList的基础结构、初始化、添加元素以及如何做到扩容的newCapablity()函数。

一、初始化

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access
        /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

平时new出无参ArrayList是一个空数组，长度为0，它是设置好的一个空数组private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

二、添加元素

	private int size;
    protected transient int modCount = 0;
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }
	private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }
    private Object[] grow() {
        return grow(size + 1);
    }
    private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
                                               }
	private static final int DEFAULT_CAPACITY = 10;
	private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE)
            ? Integer.MAX_VALUE
            : MAX_ARRAY_SIZE;
    }

    @SuppressWarnings("unchecked")
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }
    @HotSpotIntrinsicCandidate
    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;
    }

1）modCount++是用来记录array的容量修改了多少次，意思就是申请过多少数组。
2）add(E e)用来添加元素，而添加元素就必须考虑一个非常实际的问题就是容量是否够，grow函数用来扩容，而扩容的关键是newCapabilty（int minCapabilty）,如果是才申请的ArrayList，那么oldCapabilty>>1就必然是0，如果是才申请的，if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) return Math.max(DEFAULT_CAPACITY, minCapacity);就返回默认初始化大小为10.
但是不断的扩容自己一半的大小，迟早会变得很大，就用hugeCapacity(minCapacity)来控制大小，如果扩容自己一半大小的数组长度超过默认最大长度，那么就有两种扩容方式，一种是增加一个元素之后的长度大于最大默认长度，就扩容为Integer.MAX_VALUE.否则就扩容至最大默认长度。

总结

1）初始化源码分析
2）添加元素源码分析

参考文献

[1] [JDK1.12]