Java中集合长度可变的实现原理

集合的长度为什么是不固定的？

我们知道集合的底层其实也是用数组实现的，那么为什么定义集合的时候，是不需要给出size的，而数组在定义的时候就需要给出长度?

首先我们分析一下ArrayList的无参构造方法:

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * 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 == EMPTY_ELEMENTDATA will be expanded to
     * DEFAULT_CAPACITY when the first element is added.
     */
    private transient Object[] elementData;

我们发现无参的构造方法里面　this.elementData = EMPTY_ELEMENTDATA;  相当于给集合了一个空的数组，而且在第一次给集合添加元素的时候会把 DEFAULT_CAPACITY 也就是10设置成数组长度；

那么我们通过ArrayList中的add方法看一看是否是这样子:

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
　　　　　//这里elementData==EMPTY_ELEMENTDATA 也就是上面无参构造方法里的的赋值, 所以这里的判断可以理解为是否是第一次添加元素时调用此方法
        if (elementData == EMPTY_ELEMENTDATA) {
            //如果是第一次添加元素 minCapacity应该为0+1 所以这里把DEFAULT_CAPACITY也就是10赋值给minCapacity
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // overflow-conscious code
        //这里判断新添加一个元素以后 长度是否大于当前数组 如果大于则给数组扩容 
　　　　　//如果是第一次添加元素 肯定是true 然后把10传到grow方法中去
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //这里是给扩容后的数组定义的长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
　　　　　//如果是第一次添加元素 new肯定是小于min的 所以把10赋给newCapacity 用来创建长度为10的新数组
        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:
        //把原来的数组copy到新数组中  如果是第一次add 则创建了一个长度为10的数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    } 

通过上面的代码我们可以发现：

在第一次给集合添加元素的时候，的确会通过add方法及方法内调用的其他方法，创建一个长度为10的数组；

并且以后每次add的时候，都会先判断一下 size+1是否超过了数组的长度，如果超过了长度就重新定义一个长度  int newCapacity = oldCapacity + (oldCapacity >> 1) 的数组，然后把旧数组复制到新创建的数组中返回。

(oldCapacity >> 1)的意思是oldCapacity转换成2进制然后右移一位 也就是oldCapacity /2。

 

总结：

从内部实现机制来讲ArrayList是使用数组(Array)来控制集合中的对象，当你增加元素的时候，如果元素的数目超出了内部数组目前的长度，它需要扩展内部数组的长度，ArrayList是原来的50%，即newCapacity = oldCapacity+(oldCapacity/2)；