深入了解Java ArrayList及其动态调节数组容量机制

我们知道，java是允许在运行时才确定数组大小的，Object[] obj = new Object[actualSize];但是这样并没有解决动态更改数组的问题，一旦空间大小被确定，就无法再扩大了，ArrayList很好的解决了这个问题，它可以动态地增加数组列表的容量。

1.构造：ArrayList< Object> obj = new ArrayList< Object>();

jdk1.7构造函数源码：    private transient Object[] elementData;    private int size;    public ArrayList(int initialCapacity) {        super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        this.elementData = new Object[initialCapacity];    }    /**     * Constructs an empty list with an initial capacity of ten.     */    public ArrayList() {        this(10);    }

ArrayList类中存在两个私有成员（当然不仅仅只有两个），elementData是一个Object类型的数组，用来保存元素；size表示ArrayList中实际的元素数目（所以size()方法返回的是实际元素的数目）。我们可以看到以这种形式定义的数组列表的默认容量是10。这里注意一下，在以上的构造函数中，并没有给私有成员size赋值，因为size在这里表示的是实际的元素数目，而刚刚初始化之后，数组列表中是没有任何实际元素的，所以size默认为0。所以，在使用obj.get(0)是会报错的。

    public E get(int index) {        rangeCheck(index);        return elementData(index);    }    private void rangeCheck(int index) {        if (index >= size)            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));    }    E elementData(int index) {        return (E) elementData[index];    }

2.除了以上的构造方法外，当我们大致可以估计需要存储多少元素数量时，还可以用这种方法：ArrayList< Object> obj = new ArrayList< Object>(20); 这样数组列表的容量就是20了，这等价于

ArrayList<Object> obj = new ArrayList<Object>(20);obj.ensureCapacity(20);

我们来看一下ensureCapacity(minCapacity)的源码

    public void ensureCapacity(int minCapacity) {        if (minCapacity > 0)        ensureCapacityInternal(minCapacity);    }    private void ensureCapacityInternal(int minCapacity) {        modCount++;        // overflow-conscious code        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }     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);    }

看了这几段代码，ensureCapacity(minCapacity)的作用就显而易见了，就是增加数组列表的容量，原理很简单，首先判断该参数是否大于0并且是否大于当前容量，然后就到了grow方法，其他的语句先别管，看最后一句，elementData = Arrays.copyOf(elementData, newCapacity); 这条语句先按指定参数创建一个更大的数组，然后把原数组的元素一个个拷贝到大数组中，最后将elementData 的引用指向这个大数组。这样，就增大了数组列表的容量，而小数组也会被gc回收。所以数据量很大的时候还是建议初始化的时候就指定容量，提高效率

Arrays: public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {    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;}

3.看到这里，也对ArrayList动态增加数组容量有了一定的理解，现在来看看add方法在添加新元素时是怎么动态增加数组容量的

     public boolean add(E e) {        ensureCapacityInternal(size + 1);  // Increments modCount!!        elementData[size++] = e;        return true;    }    private void ensureCapacityInternal(int minCapacity) {        modCount++;        // overflow-conscious code        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }     private void grow(int minCapacity) {            // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1); //jdk1.7之后的容量增长机制是这样的，还有这样计算的newCapacity = (oldCapacity * 3)/2 + 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);    }

其实原理一样，因为数组的大小一旦确定是不能被改变的，所以当内部数组已经满了之后还要再添加元素时，是创建一个更大的数组，然后把原数组的元素一个个拷贝到大数组中，最后改变引用指向。这里有个疑问，add方法动态增加了多少容量呢，现在可以看一下grow方法的其他语句， int newCapacity = oldCapacity + (oldCapacity >> 1); 假设原容量为10，那么新容量就为15，再次增加容量会变成22，原容量不同，每次增加的容量也就不同。jdk1.7之后容量增加的计算机制是这样的，我还见过有这样的：newCapacity = (oldCapacity * 3)/2 + 1。这里要注意，如果原容量为10，使用ensureCapacity(11)，得到的新的容量不是11，而是15。所以，ensureCapacity并不是按照参数来指定新容量的。

4.

ArrayList<Object> array = new ArrayList<>();Object[] obj = new Object[10];

这两条语句都开辟了10个元素的空间，一个表示数组列表，一个表示数组。虽然ArrayList是用数组来实现的，这两者还是有一定区别的，数组有大小，是固定的；数组列表拥有的是容量，并且是可变的，数组和数组列表在初始化之后，System.out.println(obj[0]); 可以打印null；而System.out.println(array.get(0));会报错。如果不看源码，还以为数组列表连存储空间都没开辟。

5.看源码可以知道ArrayList里的方法都不是同步的，所以当不止一个线程要修改ArrayList实例时，必须让它保持外部同步。可以使用List list = Collections.synchronizedList(new ArrayList(…)); 来防止这一问题发生。